A record per action, not per session

Watch an autonomous agent do its work and you are watching not a decision but a cascade of them. It reads a ticket, queries a database, decides the balance is wrong, issues a refund, updates a record, emails the customer, closes the ticket, moves to the next. Seven consequential acts, each resting on inputs the last one produced, each executed without a human approving that specific step. When the run finishes, most systems write one thing: a transcript, or a summary, or a status of completed. And that single artifact — one row for a run that took seven actions — is offered up later as the record. It is not a record. It is a receipt for the session, and a session is not the thing anyone will ever contest.

The contested thing is always an action. Nobody comes back a month later and asks why the agent ran. They ask why it issued that refund, revoked that access, cancelled that order, sent that message — one act, singled out because it was the one that went wrong or the one someone wants to challenge. To answer, you need the account of that act specifically: the inputs it read, the authority it held at that instant, the rule or judgment it applied, the state of the world it saw, and the moment it committed. A summary of the whole run cannot supply that. It has averaged the run into a story, and the act you need is dissolved somewhere inside it, unreconstructable.

This is the first thing that changes at the frontier, and it changes quietly. In the model era, one invocation produced one score and a human made one decision — so a record per invocation and a record per decision were nearly the same object, and you could be sloppy about the distinction. An agent breaks the correspondence. One invocation of the agent produces a chain of actions, and the accountable unit is no longer the invocation. It is each act in the chain. If your instrumentation still fires once per run, you have kept a habit from a world that no longer exists, and it now records almost nothing that matters.

Why the summary always loses

You might think a rich enough transcript rescues you — capture every tool call and every intermediate thought, and surely the individual action is recoverable from that. It is not, and the reason is worth stating plainly. A transcript is a narrative the system tells about itself while running. It is continuous, unbounded, and interleaved; the boundaries of a single consequential act are not marked in it, because the system was not thinking in those units. To reconstruct one action from a transcript, you have to parse the story back into decisions after the fact — and that reconstruction is exactly the fragile, arguable, memory-like exercise the whole discipline exists to avoid. You have rebuilt recollection out of logs and called it a record.

The alternative is to make the action a first-class event at the moment it happens. Before the agent commits an act with a real-world consequence — the write, the send, the transfer, the revocation — it emits a bounded record of that act: what it decided to do, the specific inputs the decision rested on, the authority under which it acted, the policy or reasoning that produced it, and a trustworthy timestamp. One record per consequential action, sealed at the point of action, standing on its own without the transcript around it. The run then leaves behind not one summary but a small ordered set of these — a ledger of acts, each individually answerable.

A session tells you the agent ran. Only a record per action tells you what it did — and only one of those is ever put on trial.

The line between which acts get a record and which do not is not "every function call." Most of what an agent does is reading, thinking, retrieving — reversible, consequenceless, cheap to redo. Those do not each owe a record; drowning the ledger in them defeats the purpose as surely as summarizing the run does. The acts that owe a record are the ones that change the world outside the agent: the ones a person could later be harmed by, contest, or demand be undone. Draw the boundary at the seam where the agent stops deliberating and starts acting on something real. That seam is where the record goes, and it is usually a small number of places in the code, not a firehose.

The test is a single act, pulled at random

There is a clean way to know whether you have built this, and it mirrors the test we apply everywhere else. Take one consequential action the agent performed yesterday — not the run, one act inside it — and try to reconstruct why it happened using only what you persisted. Can you state the inputs that act read, the authority it held, the rule it applied, and the outcome, without replaying the session or reasoning about what the agent "would have" done? If yes, you have a record per action. If you find yourself scrolling a transcript trying to locate where in the story that act lived, you have a record per session, and the act itself is undocumented.

Public standards are converging on this same unit. As agent-specific guidance takes shape — the identity and authorization work now underway at the standards bodies, the emphasis in the current agentic security top ten on logging every tool call, decision, and the reasoning behind it — the through-line is that the auditable object is the agent's action, not its run. The frontier is not asking for more logs. It is asking for the logs to be organized around the right noun. A thousand lines of transcript are worth less, when a decision is contested, than seven sealed records of the seven acts that actually touched the world.

None of this slows the agent down or changes what it does. The same runs produce the same actions; what is different is that each consequential act now leaves behind a bounded account addressed to the only question it will ever face adversarially — why this one, on what authority, resting on what. Build that at the moment of the act and it costs almost nothing. Try to reconstruct it later from a session summary and you will find the same thing you always find when you skip the record: the run is remembered, the action is gone, and gone at exactly the moment someone needs it most. Move the instrument. Fire it once per act, not once per run.

— Dispatches · The Frontier · Summit Cognitive