The answerable party

Accountability has always rested on a quietly convenient assumption: that when something happens, there is a person who did it. Not in the loose sense that a person is somehow to blame, but in the exact sense that a specific human being took a specific action and can be asked, afterward, to account for it. For most of the history of automation this assumption held without effort, because the machine advised and the person decided. The system produced a number, a ranking, a flag; a human read it and acted; and the human who acted was, unambiguously, the answerable party. Autonomy breaks that assumption — not by removing the answerable party, but by scattering the candidates for the role across a crowd, and leaving no one obviously standing in it.

Consider what happens when an agent, rather than a person, takes the action. It calls a tool. It moves money between accounts. It files a ticket, cancels an order, revokes an access grant, escalates a case. No human approved that specific act; a human configured the system, set a goal, granted it some authority, and then went to lunch. When the act turns out to have been wrong, the question who is answerable for this no longer has a single obvious owner. It has a lineup: the operator who ran the agent, the deployer who put it into production, the author who wrote the agent, the person who set the goal it was pursuing, the vendor of the underlying model it reasoned with. Each can, with a straight face, point to one of the others. And in the space between those pointing fingers, responsibility does not get divided. It evaporates.

The diffusion of the answerable party

The advisory era's clean assignment worked because the human decision was a bottleneck, and bottlenecks are wonderful for accountability. Every consequential act passed through a single conscious person who could be named, questioned, and — this is the part we forget to be grateful for — who remembered. If you wanted to know why a loan was denied or a shipment held, you asked the person who denied it or held it, and their memory, however imperfect, was a record of a kind. The whole apparatus of responsibility that we inherited from the pre-automation world assumes this witness exists: a party who was present at the act and can be made to speak to it.

An autonomous agent removes the witness without removing the act. Fifty consequential things happen in a run, and no human was present for any of them in the sense that matters. You cannot ask the operator why the agent moved the money, because the operator did not move it and was not watching when it did. You cannot ask the model vendor, because the vendor sold a capability, not a decision. You cannot ask the goal-setter, because the goal was “resolve the backlog,” not “take this act.” The candidates multiply precisely because the connective tissue between the human and the act — presence, attention, memory — has been cut. Diffusion of the answerable party is not a bug in some particular system. It is the default condition of autonomy, and it arrives the moment you let a system act on its own.

Standing is assigned, not discovered

The instinct, when something goes wrong, is to reconstruct: to assemble the logs after the fact and reason backward toward whoever must have been responsible. This is a trap, and an expensive one. Reconstruction of responsibility after the act is an argument, not a fact — it is a thing lawyers do, at length, to no settled conclusion, because the raw material was never designed to settle it. If the record was not built to say who was answerable, then afterward everyone is free to argue that it was someone else, and the argument has no natural end.

The alternative is to treat standing as something you assign at the moment of action, not something you hope to discover later. A record worth the name does not reconstruct the answerable party; it names one, at the act, as a fact: under whose authority this was done, on whose goal, within whose grant. This is where authority stops being a security concern and becomes the load-bearing accountability fact. An act taken inside a narrow, recorded grant has an author by construction — the party who holds the grant. The record does not have to guess; it can point. An act taken outside any such grant has no author at all, and that absence is itself the most important thing the record can tell you. The question is not “who turns out, on reflection, to have been responsible?” It is “whose authority was this act an exercise of?” — and that question has an answer only if the answer was written down when the act occurred.

An action no one can be made to answer for is not autonomous. It is merely unowned — and an unowned act is not a triumph of engineering but a failure of standing.

This is what a Decision Receipt is for at the frontier: not to explain the agent's reasoning, but to fix the assignment. To carry, inside the record of the act, the authority it was taken under and the party who held that authority, so that standing is a recorded fact and not a later contest. The point is not that the receipt tells you the agent was right. The point is that it tells you, without argument, who has to answer if it was wrong.

Why “the vendor did it” is a non-answer

The most tempting escape from all this is to push the answerable party outward, toward whoever supplied the capability. The model did it. The vendor did it. The framework did it. These sound like answers and are not, because they confuse the source of a capability with the authorship of an act. You can buy a capability. You cannot buy your way out of answering for the act you deployed it to take. A firm that arms an autonomous agent with the power to move its customers' money, and points it at a goal, and lets it run, has not transferred its accountability to the model's maker any more than a company that buys a fleet of trucks has transferred its accountability to the manufacturer for how it chooses to drive them.

The generic shape of the error is always the same. Something goes wrong; the deployer says the model behaved unexpectedly; the model's maker says the deployer used it outside its intended envelope; and both are, in a narrow sense, telling the truth, which is exactly why neither statement resolves anything. What resolves it is a prior fact: that the act was taken under a grant of authority that some named party held and configured. That party is answerable, not because they foresaw the specific failure, but because the act was an exercise of authority they chose to confer and chose to leave unsupervised. Capability flows in from the vendor. Authority is conferred by the deployer. And answerability follows authority, not capability — which is why “the vendor did it” describes where the power came from while saying nothing about who is answerable for its use.

None of this is an argument against autonomy. It is an argument that autonomy raises the bar rather than lowering it. A system that merely advises can lean on the human it advises to be the answerable party. A system that acts cannot — it has to carry its own standing, assigned at the act, or it has none. The affected party who wants to contest what was done to them needs, first, someone to contest it with; and that someone exists only if the record named them when the act occurred. Build the assignment in, and autonomy stays answerable. Leave it out, and you have not built an autonomous system. You have built a machine for producing consequences that belong to no one.

— Dispatches · Summit Cognitive