Co-Authored-By
Open my git log. This morning I pushed a commit renaming an app across my portfolio. The commit ended with the line every Claude Code session leaves behind —
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Scroll a few commits back and the line changes shape:
Co-authored-by: Cursor <cursoragent@cursor.com>
That line is also relatively new. Cursor used to ship its commits with Made-with: Cursor, which is the language a maker uses to describe a tool. It changed, quietly, to the co-authored-by form some time recently. The shift is small but the direction is the point: made-with is the language of tools; co-authored-by is the language of participants.
Scroll further. Some commits end with no co-author line at all. Those are the sessions with OpenAI’s coding agent, which by default does not name the agent in the record.
One repo, one developer, three coding agents. Two practices. One of the two is itself moving.
I have been pushing commits with these trailers — or without them — for months without paying attention. Today, having spent the morning reading a federal court ruling I had not yet connected to them, the lines in my log looked different than they had yesterday.
Two months ago, a federal court asked the same question about a different kind of agent acting in a different kind of record. Perplexity’s Comet browser had been shopping on Amazon on behalf of its users — logged into their accounts, identifying itself to Amazon as Chrome. Judge Maxine Chesney drew the distinction that mattered: Comet accessed accounts with the user’s permission, but without Amazon’s authorization. The injunction names no agent. The remedy is against Perplexity. The legal artifact records nothing about the thing that did the action — only about the company that built it.
Three records this year had to register an agent’s presence. They register it three different ways.
The word arrived with rules we did not borrow.
The word “agent” did not arrive empty. In law and economics, an agent is a particular kind of party — one with the legal authority to act on behalf of a principal, whose actions bind that principal, who has duties to act in the principal’s interest, and who can be sued for failing those duties. An employee is an agent. A lawyer is an agent. A power-of-attorney holder is an agent. The relationship is centuries old, and the word carries the weight of every case that has shaped it.
When we started calling AI systems “agents” three years ago, we did not import any of that. We took the word for its other meaning — something that acts — and dropped the part where an agent is also a party with duties, standing, and the ability to be served with process. The word arrived in our vocabulary with its rules quietly stripped off. We kept what was useful. We left behind what would have made the rest of the work harder.
This is not a complaint about word choice. It is an observation about what the vocabulary lets us avoid. As long as we are talking about “AI agents” without the legal scaffolding, we can keep the question of what they are perpetually open. The word does not commit us. It floats.
Two coherent views — and one is winning.
If the word does not commit anyone, what are the people running coding agents actually committing themselves to? Look at the divergence.
The tool view has a clean internal logic. A coding agent is a sophisticated text transformation — you ask it to write code, it writes code, you commit the code. This is what compilers do. This is what autocomplete does. This is what an IDE does. None of those tools get a line in the commit. None of them have ever been considered an author. Codex’s default is to leave the line off because, on the tool view, there is nothing to name. The human typed the prompt, the human accepted the output, the human signed the commit. One actor, one signature.
The participant view has a different logic. A coding agent is not merely a text transformer. It makes choices the human did not foresee — picks an algorithm, names a variable, restructures a function, decides what to test. When the human reviews the result, they are reviewing decisions the model made, not output a tool generated under tight specification. Naming the agent in the record is not a status claim. It is a description: this commit had two contributors. The trailer line — Co-Authored-By: Claude Opus 4.7 — does not say the agent is responsible. It says the agent was there.
Both views are coherent. Both have costs. The tool view keeps accountability clean — one human, one signature, one place to point when something breaks — at the cost of an audit trail that hides what actually happened. The participant view records what happened more honestly at the cost of making a soft status claim about a thing the law has not figured out how to recognize.
The interesting thing is that the participant view is winning. Cursor’s evolution is the visible piece — Made-with is the tool framing; the trailer is the participant framing; they moved. AI Has No Needs argued that the division of labor that actually works is one where the human supplies the felt direction and the model supplies the recombination. That division is not the same as “human uses a tool.” It is closer to “two parties, different roles.” The trailer is what that division looks like when it shows up in the artifact.
Where the responsibility actually lands.
The disagreement is not just about whether to name the agent. It is about where to put the responsibility for the action. And once you draw out who is actually in the room when an agent acts, the disagreement has a particular shape.
There are at least four parties present when a coding agent commits code or when a browsing agent acts on a platform. The user — who prompted, who said do this. The operator — the company that built and ships the agent. The model provider — sometimes the same company, sometimes not, but always whoever trained the underlying model that did the work. And the platform — the system on which the action lands, the one that has to live with the result.
Each artifact pins responsibility on a different spot. The tool view leaves the agent unnamed and the operator unnamed; the user signs and bears it all. The participant view names the agent (Co-Authored-By) and still has the user sign; responsibility is primarily the user’s, with the agent visible but unbound. The Comet ruling skips both user and agent and pins liability on the operator — Perplexity is the entity enjoined, the only name in the legal record of the harm.
What none of the three does is put responsibility on the agent itself. When the Agent Browses for You asked what your agent had access to — files, terminal, accounts. The question that follows is harder: when the agent uses that access in a way that produces harm, who is on the hook? In every artifact I can find, the answer is some human or some company. Never the agent. The thing that did the action is the one party with no slot in the responsibility map. The act exists. The actor does not.
This is not because anyone has argued the agent should be left out. It is because there is no available legal entity to put there. You cannot sue a model. You cannot enjoin a context window. The law has nowhere to send the bill. So the bill goes to the nearest party that has a corporate filing.
Three bets, no referee.
This is what the three positions actually amount to: three running bets, made by different parties, in venues that do not talk to each other. Anthropic and Cursor are voting in commit trailers. OpenAI is voting by omission in the same place. The Northern District of California is voting in injunctions. The conventions are converging in some directions — Cursor moving toward the trailer form, Anthropic getting more specific about which model and configuration ran — and diverging in others. None of these venues has the authority to settle the question for the others. None of them is even trying.
Inside one workflow the bets can stack. A developer using Claude Code (participant view) to build an agent that runs against a third-party platform (operator view) is operating inside two of the three positions at once, with different parts of the same workflow recording responsibility differently. The trailer says the human and the agent co-authored the code. The platform, if something goes wrong, will sue whoever shipped the agent. The user who started the chain is barely in either record.
From Prompts to Harnesses closed on a prediction: that governance would be the institutional layer above harness engineering — that every category of meaningful automation eventually grew a regulatory frame around it. The Comet ruling is the first concrete stone of that frame, and it is the shape the architecture forced. Not a thoughtful framework. A search for the nearest suable party.
The frame is being built. It is being built by people who are not coordinating, in records that do not cross-reference each other, with no shared vocabulary for what is being decided. Every operator that ships an agent makes one micro-decision about how the agent is registered. Every court that rules on an agent’s action makes one macro-decision about who pays for it. The decisions accumulate. The shape they form is what the institutional layer will turn out to be.
The most honest record we have right now.
The trailer at the bottom of this morning’s commit was not put there as a vote on any of this. It was put there because Anthropic shipped Claude Code with that default, and I never turned it off, and every push since I started using the tool has carried it. I noticed it again today only because I had been reading the Comet ruling, and the line had picked up the weight of a question I had not connected it to.
The three positions are not equal. The tool view treats the agent as if nothing has changed about authorship, which is increasingly hard to believe — the thing producing the code is not a compiler. The operator view treats the agent as a corporate liability to be billed to its parent, which solves the harm question but skips both the human who directed and the agent that acted. The trailer is the only one of the three that names what is actually happening — a human directed, an agent participated, both visible in the record. It does not yet say what either of them is responsible for. But it stops pretending the question has already been answered.
That is not the same as saying the trailer is the right answer. It is one operator’s experiment, recorded honestly, in advance of any standard. Cursor adopted it after starting somewhere else. OpenAI has not, yet. The industry is mid-conversation, and what the trailer offers is the most honest existing artifact of an unresolved question — a small, structured admission that something happened in this commit that the old vocabulary does not describe.
Every commit I push is a small vote. Until something else fills the gap, the trailer is the most honest one available.