An autonomous agent has to verify its own work
Agent-built features can look finished and be broken. The user will not check, so the agent has to, and that changes how you build one.
Written by
-
Benedikt Stemmildt Founder & Co-CEO
Published: 9 July 2026 Updated: 2 min read
There is a failure mode in agent-built software with a great name: the painted door. A button that looks fine and does nothing. Mock data shown as if it were real. A handler nobody wired up.
Users do not click every button to check, so a feature that only looks finished ships broken, and nobody catches it.
The user will not verify, so the agent must
This is the core problem of autonomous agents. The user is not going to verify, especially a user who is not an engineer. So the agent has to verify itself. An agent that only builds is half a factory. The other half is the validator.
Three things hold an autonomous agent together.
Model capability is rented
The first is raw model capability. You do not control it. You rent it from whichever lab is ahead that quarter. Spend your attention elsewhere.
Verification is the half teams skip
The second is verification, and this is the half I see teams skip most. Test for correctness at every step, because errors compound without it. The progression runs from static analysis to code execution, then unit tests, then API tests, then a browser actually clicking through the result.
The trick worth stealing: do not drive the browser with screenshots. Generate real test code. A model writes it fluently, and the tests survive as a regression suite at a fraction of the cost.
Context management keeps the loop coherent
The third is context management. Long-context models are not the answer. Even an ambitious task fits in a normal window with proper offloading. The codebase is the state. The file system is the memory.
A sub-agent is the separation of concerns: spawn it with a fresh window, give it the minimum it needs, let it finish, return only the result, discard the rest. The main loop stays coherent because the click-observe noise never enters it.
What autonomy turned out to mean
Autonomy here is the span of time during which the user makes zero technical decisions and the agent still reaches a result you can verify. Long runtime on its own is a vanity number. Narrow scope with real verification beats broad scope with hope.
The builder was always the easy half to staff. How much of your agent’s day goes to verifying its own work, and what breaks if the answer is none?
Further reading
Written by
-
Benedikt Stemmildt · Founder & Co-CEO
More on Specification and review
- Verification in a Software Factory When generating code gets cheap, a Factory's throughput depends on how well the system can establish that a change is acceptable, safe, and worth shipping.
- Refinement, not coding, was the bottleneck all along Several teams turned the same rough story into wildly different plans. The agent did not create the ambiguity. It showed that deciding what the work means was always the slow step.
- 1,300 agent PRs a week rest on three million tests Stripe's 1,300 unattended pull requests a week get quoted everywhere. What makes them work is the test layer and the harness underneath the agents.
Test the constraint in your system
The Factory Readiness Assessment connects this research to your value stream, your data, and the next decision.
Training on this topic: Agentic Engineering for Developers and QAWant to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check