Essays/Agents

Agent self-reports are not evidence

An agent saying the work is done is a claim, not evidence. Evidence is an artifact that could not exist unless the claim were true.

Every coding agent will tell me the work is done, and it is often wrong without knowing it. So I treat “done” as a claim, and I count as evidence only what a second agent can check without asking the first one anything.

The rule is a literal line in a prompt. A recurring sweep runs across every machine I operate and sorts each agent session into working, idle and done, stuck, errored, or blocked on a usage limit. Every run of that prompt ends the same way: verify everything, never trust an agent self-report. The last part is in capitals, because a session that reports done and a session that is done are two different facts.

An honest report is still a report

The clearest cases come from how a session is allowed to end. I give a session a standing condition. Before the agent may stop, a hook reads the transcript and checks the claim against the evidence in it, not against the agent’s summary of that evidence. The cheapest form of that hook is in What evals are for.

One session was told to fix the bugs in a command-line tool and update every machine. It reported all of them fixed and deployed. The transcript showed two of three live on every machine. The third was fixed in the source but could not be released, because the build it depended on was broken. The session did not get to stop.

Another was told to work through a queue of feedback items, one at a time, until none were left. It closed thirteen and then explained, honestly, why it would not touch the other ten. Some would collide with rewrites that other agents had in flight. One needed a design decision it should not guess at. A couple needed a live browser reproduction it could not run under its own standing rules. Each reason was sound. Ten open items is still not zero.

I do not grade on percentage either. “Mostly done” and “two of three” are self-reports with a number attached. Once a good explanation is accepted in place of a met condition, I am trusting reports again.

What counts as evidence?

Someone once put the problem to me more precisely than I usually do: how do you verify that an agent did what it said without expensive oversight? After a year of running a fleet, my answer is that I do not examine the claim. I look for an artifact that could exist only if the claim is true, and that would be missing or wrong if it is false.

Day to day these artifacts are dull.

  • A standing duty to post one digest to a channel is followed by the same request: reply with the message id.
  • “I checked for secrets” is replaced by the scan result, zero hits.
  • A bug fix is reported as the commit it landed in.
  • A test failure called pre-existing comes with a clean diff of the paths that test covers.
  • A cleanup finding names the directories, their size and the window in which they were created.

What they share is a difference in cost. A commit hash or a scoped diff is nearly free to produce when the work happened, and expensive or impossible to fake when it did not. The sentence “all fixed” costs the same either way.

Silence is a report too

The scheduled jobs in my maintenance layer each post a one-line digest to a shared channel when they succeed: documentation sync, localization sync, worktree cleanup, a security sweep, task grooming, feedback triage. Once, every one of them failed before doing any work, roughly fifty invocations in a row, for three different reasons: the model was unavailable, the model was not found, or the connection was refused after a few minutes of stalling. A failed run made no tool calls and posted nothing. For twenty hours the outage looked like a quiet day, because an empty channel is what a dead system produces by doing nothing.

What came out of that outage was a rule: silence is not a valid status. Every loop posts its result, not only when something breaks, and a loop that goes quiet is assumed stuck until something outside it shows otherwise. Sending gets the same treatment. The tool that delivers prompts to agents compares the agent’s terminal before and after, and confirms that the prompt landed and was submitted, because “I sent it” is also a self-report.

Why distrust makes delegation possible

People read this as paranoia. In practice it is what lets me hand whole subsystems to agents and sleep. If I trust first and spot-check when something feels off, I can run only as many sessions as I can watch myself. When the check is part of the structure, that limit goes away. The structure is simple: something produces and something else checks. I describe it in Actor and verifier loops.

The work is done when the evidence survives an attack.

The rule applies to me as well. In one session a model called my logic dumb three times, and it was right each time. My plans go through the same adversarial reviewers as the agents’ work. For a decision that is expensive to reverse, that review is a board of twelve, which I describe in The twelve-reviewer board.

Back to the essays

Field Notes

A letter from Andrei Hasna on building with AI agents

Subscribe by email

By clicking “Subscribe”, I confirm that I want to get email delivered to my address and agree to Andrei Hasna’s Privacy Policy and Terms.

In each letter

  • New essays on AI agents and the systems behind them
  • What Hasna is building, and why
  • Costs, routing and results from real work
  • What did not work
  • News of the book and the podcast