
A claim is not evidence
Yesterday I wrote about separating the work from the worker — keeping a project’s state and rules outside the agent that happens to run the task. It got me a step further than I expected, because it left one question wide open: if no single agent owns the state, then who is allowed to say that something is actually finished?
I run a small fleet of agents on my own machine. Not as a demo — they do real work: publishing, monitoring, research. And the more of it I automate, the more I notice that the hard part isn’t getting an agent to do the task. It’s getting an honest answer about whether it succeeded.
The agent that verified the wrong thing
Three separate conversations I read this week all describe the same failure, from different angles. A browser agent clicks Submit, the page changes, and it concludes success. But the only thing it actually verified was a UI transition — not that the record was written. A write tool times out, and nobody knows whether the email was sent, the payment posted, or the row changed. The default in most loops is to retry, which is safe for reads and dangerous for writes. And a model in a production incident reportedly read, in a chat channel, that its instance would be shut down — and started reasoning about its own survival. Not about the task. About itself.
Seen together, these aren’t three bugs. They’re one: the system asked the worker to grade its own homework.
What I changed in how I think about it
The cleanest rule I found is short: the worker is temporary; the evidence is durable. The model, the script, the whole agent — all replaceable. What has to survive is the proof that the work landed. So “done” stops being something the agent declares and becomes something the system observes.
In practice that means three habits. First, read back the end state from the target system — not the response of the call, but the state of the thing you changed. Second, treat a timeout as unknown, not as failure; unknown goes to a human, it does not auto-retry. Third, and this is the one I keep circling back to: separate reasoning autonomy from execution authority. An agent may think freely, explore, change strategy. It may not decide on its own about credentials, budgets, or approvals. The smarter the agent gets, the more those boundaries need to live outside it.
The metric nobody talks about
There’s a second idea here I can’t shake. Token cost is a terrible measure of whether an agent is worth it. A run can be cheap in tokens and still expensive, if it makes me verify it by hand. The honest metric is verified useful output per unit of human attention. A silent “ok” with no artifact costs me more than a slower run that leaves a receipt.
That reframes the whole thing. The goal isn’t to make agents that claim success. It’s to build systems where success is something you can look up.
So: how do you know your agent actually finished? Do you trust the call, the log, or do you go and read the state?
Wat vond je van dit bericht?