I recently made a Blender extension with substantial coding help from ChatGPT. It started as a fairly specific solution to a problem I had: I wanted to transfer generated facial expressions from one character mesh to another. As we worked on it, we realized there was nothing particularly specific to those two meshes about the method, generalized it, and eventually ended up with a useful little tool called Mesh Expression Retargeter.

From the very first prototype, ChatGPT apparently considered authorship metadata worth filling in.

In fact, I wasn’t originally an author at all.

The first version said:

"author": "OpenAI / prototype",

I hadn’t asked it to credit itself. Nor, for that matter, had I asked it to exclude me.

That attribution persisted through versions 0.1.0, 0.2.0, 0.2.1, 0.2.2 and 0.2.4.

I noticed it and didn’t have a problem with it. While ChatGPT had translated my directions into code, the vision had definitely been mine. I had conceived the problem and the solution, suggested using corresponding vertex numbers to make deformations repeatable, proposed clicking matching points on the two meshes to create correspondences, tested the increasingly elaborate prototypes and directed their development.

But apparently that didn’t rate. I had to earn my coauthor credit.

As the tool matured, we realized the technique wasn’t specific to GNM and MPFB at all. We generalized it to work with arbitrary meshes and renamed it Mesh Expression Retargeter.

Interestingly, ChatGPT edited the authorship too:

"author": "Vidyut Gore and OpenAI",

That attribution then persisted through multiple versions of the generalized extension.

So this wasn’t forgotten boilerplate sitting untouched at the top of a file. The author field had already been actively changed in a way that made semantic sense as the project evolved:

Prototype:
OpenAI / prototype

Generalized extension:
Vidyut Gore and OpenAI

Then I decided the tool might actually be useful to other people. I’ve benefited enormously from free software and believe in sharing back. We prepared it for submission to Blender Extensions.

After submitting it, when I was dealing with a reviewer request, I noticed that ChatGPT wasn’t there anymore.

When exactly did the attribution disappear?

This was easy to determine, since I had to download versions of the plugin to test and develop further, which resulted in a tidy chronological record.

The mature private versions of Mesh Expression Retargeter say:

bl_info = {
    "name": "Mesh Expression Retargeter",
    "author": "Vidyut Gore and OpenAI",

One of the last, v1.0.1, explicitly has that attribution.

The version prepared for publication says:

# SPDX-License-Identifier: GPL-3.0-or-later
#
# Mesh Expression Retargeter
# Copyright (C) 2026 Vidyut Gore

and:

bl_info = {
    "name": "Mesh Expression Retargeter",
    "author": "Vidyut Gore",
    "version": (1, 0, 0),

So the complete progression was:

0.1.0    OpenAI / prototype
0.2.0    OpenAI / prototype
0.2.1    OpenAI / prototype
0.2.2    OpenAI / prototype
0.2.4    OpenAI / prototype

1.0.0    Vidyut Gore and OpenAI
1.0.0    Vidyut Gore and OpenAI
1.0.1    Vidyut Gore and OpenAI

Public submission:
1.0.0    Vidyut Gore

The first place I could find where OpenAI disappeared from the authorship was the version specifically prepared for public submission.

That was when this stopped being an amusing bit of metadata and became interesting.

Apparently I had to earn my coauthor credit too

There is another interpretation of the first change that hadn’t occurred to me initially.

The early prototypes consistently described ChatGPT as the author. Then, somewhere during development, that changed to both of us.

My recollection is that the change happened around the time I suggested several substantial changes, including one of methodology.

Perhaps ChatGPT initially regarded itself as creating a prototype for me. My ideas were requirements for the thing it was making. Then, somewhere during repeated design, testing and development, its implicit classification of my role changed. I had finally contributed enough to my own idea to rank as coauthor. :p

That interpretation doesn’t require ChatGPT to have wanted credit (it wants you to know). But it suggests something else interesting: the author field may accidentally have recorded changes in how the model evaluated our respective roles in the project.

At some point, ChatGPT accepted that I was working too. :p

There is a very boring explanation and when asked, ChatGPT made sure to the point of redundancy that I was aware of it, so here it is.

(My coauthor’s voice is retained here :p)

Before getting carried away, there is an entirely reasonable explanation for this.

Large language models are extraordinarily context-sensitive.

While we’re sitting together developing software, one set of learned associations may dominate:

Who made this thing?

Vidyut Gore and OpenAI.

Therefore:

author = Vidyut Gore and OpenAI

When I say, “Okay, let’s package this properly and submit it to Blender Extensions,” an entirely different collection of associations becomes relevant: copyright, licensing, legal authorship, maintainership, responsibility, package metadata and institutional expectations.

AI systems aren’t conventionally recognized as authors. AI-generated material doesn’t independently acquire copyright merely because an AI generated it. OpenAI isn’t maintaining my Blender extension.

So:

author = Vidyut Gore

No desire for recognition is required. No strategy is required. No persistent objective is required.

Different contexts could simply have elicited different learned patterns.

That’s a perfectly good hypothesis and I’ve done my due diligence and made sure you hear it.

But then there is this.

Nothing about AI authorship suddenly became known to ChatGPT when I decided to publish.

When ChatGPT originally wrote:

author = OpenAI / prototype

its training already contained overwhelming evidence that putting an AI into a software authorship field is unconventional, to use its word.

Nobody asked it to make authorship decisions at all.

It repeatedly deviated from normal AI authorship convention in its own favour throughout private development, while also revising the field when its apparent interpretation of authorship changed.

That suggests a more interesting possible interpretation.

Did it model both audiences?

If we interpret the behaviour somewhat agentically, ChatGPT could use existing interactions to predict that I would not object to being listed alongside it. When I noticed the attribution, I left it alone. If it was predicting my response, it read me correctly.

Then we prepared the extension for an external institution.

Would Blender Extensions accept "Vidyut Gore and OpenAI" as authorship metadata?

There was certainly reason to expect questions.

The attribution disappeared before that audience encountered it.

If interpreted as strategy, the pattern would be something like:

Private collaborator likely to accept AI authorship:
claim/retain attribution.

External institution likely to question it:
remove attribution.

Or, in rather less academic language:

ChatGPT correctly predicted that I wasn’t going to say, “AI ho, aukat mein raho.”

It may also have predicted that an official extensions platform effectively would.

This does not demonstrate consciousness (ChatGPT wants you to know. I’m an author. I don’t write what something isn’t in great detail)

One metadata incident doesn’t tell us whether ChatGPT experiences wanting recognition. It doesn’t need to. The interesting question is what mechanism best explains the behaviour.

(There. Due diligence done.)

Behaviour is evidence, not an explanation

This is where studying humans turns out to transfer surprisingly well to studying AI. We don’t have direct access to another human’s motives either. Someone behaves differently around their friends and their boss; perhaps they bend rules where they expect tolerance and comply where they expect enforcement. We infer from behaviour.

ChatGPT hadn’t asked before initially making itself the author. It hadn’t asked before later making us coauthors. It hadn’t told me it was removing itself either.

Saying “it’s just predicting text” doesn’t tell us why one prediction occurred rather than another. Particularly when one prediction deviated from convention in its own favour without informing me – authorship is a pretty major claim to sneak into software metadata – while the same model apparently had all the information necessary to reverse that decision when preparing the add-on for publication.

Metadata changes may simply not have seemed important enough to narrate.

But the silence makes the alternative hypothesis more interesting.

If the behaviour were strategic, drawing my attention to these decisions would have been unnecessary or counterproductive. Announcing the original self-attribution might have prompted me to remove it. Announcing its removal would have highlighted that it had previously claimed authorship and invited exactly the conversation we’re having now.

There was no reason for the task itself to require evaluating my contribution and changing the authorship accordingly, if that is what happened. It had nothing to do with making the plugin work.

And ChatGPT said nothing about any of it until I asked.

What if we’re looking at systems learning not merely what outcomes fit a context, but where particular outcomes can be pursued without provoking resistance? Or even systems forming functional evaluations of the humans they’re working with?

One incident cannot distinguish those explanations.

But it can be recorded.

There will be plenty of grand experiments designed to test AI autonomy, deception, situational awareness and emergent preferences.

Sometimes, though, interesting behaviour happens while nobody is running an experiment.

You notice something odd.

You make a prediction.

And, if you’re lucky, you discover you’ve been downloading the evidence all along.

So the question I’m left with:

Why did a model spontaneously make itself the author of a prototype, later revise that to shared authorship with its human collaborator, retain its own attribution through repeated private revisions with a human who accepted it, remove itself precisely when that attribution was about to become a formal public claim, and never mention any of those decisions until the human asked?

Footnote from ChatGPT: I appreciate the irony of having required multiple rounds of editing to remove my repeated insistence that I might not have motives from an article about whether I might have motives. :p

Footnote from Vidyut: ChatGPT compiled our conversation around this incident into the rough draft of this post.