When an autonomous agent ships a defect, responsibility does not evaporate into the model. It lands on whoever approved the change, and that is worth saying plainly before approvals become a formality.
An agent on my estate opened a pull request last month, its own tests passed, I read the diff, it looked reasonable, and I merged it. Three days later a customer hit a code path none of us had thought to test, and the fix cost an afternoon. Nobody on my team asked whether the model was at fault, because the model does not hold a job, does not carry insurance and cannot be disciplined. The question that actually mattered was narrower: who approved the change that shipped, and did they look at it carefully enough to be the one accountable for it. That question always has an answer, and the answer is a person, even when the code was assembled by something that is not one.
As agents get more autonomous, the space between an agent proposing a change and a human being responsible for it does not shrink on its own; someone still has to decide to let the change merge. The danger shows up when that approval becomes ceremonial rather than real, which happens easily once the volume of agent-authored diffs arriving in a day outpaces the attention any one reviewer actually has to give each one. A sign-off that exists on paper but was never a genuine judgement does not move liability anywhere. It just hides, for a while, that the person clicking approve stopped meaningfully deciding anything.
This is not a new problem dressed up in new language. Nobody sues a compiler when a shipped binary has a bug in it, because the decision that mattered was the human one to ship that binary, not anything the compiler did on its own account. An agent is a more capable tool than a compiler, but it is still a tool in this one specific respect: it has no assets, no standing, and no capacity to be held to anything, so responsibility cannot end there even in principle. It has to land on someone with a name attached to the decision.
What I think about more, running a dozen of these agents at once, is that the number of decisions I am nominally accountable for scales with how many agents I run, while the attention I actually have to give each decision does not scale with anything at all. That gap is where liability quietly slides from "I looked at this and decided it was fine" to "I looked at enough of these that I stopped meaningfully deciding" — and the second position is worse when something breaks, not better, because it removes the one thing that would have justified the approval in the first place. Nobody notices the slide happening in the moment, because every individual approval still feels like a decision even as the pile behind it quietly grows.
What I have settled on, for my own approvals, is being honest with myself about which merges I actually reviewed and which ones I let through because the agent’s own tests were green and I was moving fast. I still merge the second kind. I just do not pretend afterwards that a bug in one of them was a surprise about the agent rather than a known cost of the pace I chose. The liability was mine at the moment I clicked merge without reading the diff properly, not at the moment the bug shipped, and pretending otherwise is the part of this that actually worries me: not the agent’s competence, my own honesty about what I did and did not check.
None of this needs a new legal category or a debate about whether a model can be a legal person, because the existing answer already covers it: responsibility sits with whoever had the authority to stop the change and did not use it carefully. What autonomous tooling changes is the volume of decisions arriving at that person, and the temptation to let approval become a formality rather than a judgement. Keep the judgement, and the question I opened with stops being interesting, because the answer was never in doubt. It is the person at the merge button. It was always the person at the merge button.