Why AI agents need an independent completion layer
An agent that grades its own work is not reporting a result, it is reporting an intention. The gap between those is where autonomy breaks.
Every autonomous system eventually faces the same question: who decides when the work is done?
For agents writing software, the answer today is the agent. It performs a task, evaluates its own output, and reports completion. The loop closes on itself.
The structural problem
This is not a claim that models are unreliable. It holds even for a model that is right almost always.
A system checking its own work can only check what it considered. Its errors and its checks are drawn from the same understanding, so they correlate. When it is wrong about what mattered, it is wrong in both places at once, and the check passes precisely when it is least useful.
Adding a second model to review the first helps less than it seems, for the same reason: two systems trained on similar data, prompted from the same context, share blind spots. Correlated reviewers produce confidence, not evidence.
An agent grading its own work is not reporting a result. It is reporting an intention.
Why it becomes urgent rather than staying annoying
Right now a human is usually in the loop. The agent claims completion, someone glances at the change, clicks through the feature, and catches the worst of it. That informal review is doing enormous unacknowledged work, and it is the thing that scales worst.
Three curves move against each other:
- The number of changes agents produce is rising quickly.
- The number of humans available to personally confirm each one is flat.
- The consequence of an unverified change is unchanged, because customers experience failures exactly as they always did.
Nothing about that requires agents to get worse. It only requires them to get more productive, which is the entire point of them.
What an independent layer has to be
- Outside the agent. Different process, different inputs, no access to the reasoning that produced the work.
- Grounded in the deployed system, not the source. It has to exercise the real thing.
- Answering a stated outcome, so the check does not inherit the implementation's assumptions.
- Able to refuse. A layer that cannot return no verdict will eventually be pressured into returning a convenient one.
The last one is the one people skip. A verification system that always produces an answer is easier to build and easier to sell, and it is worth less, because the answer is sometimes invented.
The loop this makes possible
Independence is not only a safety property. It is what lets the loop close without a human in it.
If an agent can be told, with evidence, that the outcome it claimed did not happen, it can act on that. It can repair the work and ask again. The verification does not need to know how to fix anything. It needs to be right about whether the result is true, and specific enough about what it observed that the fix is derivable.
That is the difference between an agent that reports done and a system that can actually finish.