The Verification Gap: Why Agentic Does Not Mean Autonomous

September 8, 2026·8 min read

For three years the story about reasoning models was that bigger models reason better. The evidence points somewhere cheaper and less glamorous. DeepSeek-R1 and OpenAI’s o1 both got good the same way: they were trained on problems with checkable answers, and the reward was whether the answer was right. Verification is the part that works.

DeepSeek’s R1 paper reports that reasoning “can be incentivized through pure reinforcement learning,” with no human-labeled reasoning traces, and that the training produced “self-reflection, verification, and dynamic strategy adaptation.” The gains concentrate on what the paper calls verifiable tasks: math, coding competitions, STEM. OpenAI’s o1 post makes the same move. The model learns to “recognize and correct its mistakes” through reinforcement learning on chain-of-thought.

The AIME numbers make the point more sharply than the prose. GPT-4o solved 12% of the 2024 AIME problems. o1 solved 74% with a single sample, 83% with 64-sample consensus, and 93% when re-ranking 1,000 samples with a learned scoring function. Consensus and a learned verifier are verification machinery, and they buy almost twenty points over the raw model. Verification is not optional. It is the mechanism that turned the reasoning curve upward.

Agents did not inherit it

Dan Luu ran a pre-registered experiment to find out whether telling an agent to use a specific testing or verification technique makes its code more correct. He reused his Zstd-in-Rust eval, with 26 prompt conditions plus four testing skills, 80 runs per condition at medium effort and 80 at xhigh on Codex with GPT-5.6 Sol. The conditions cover most of what you would reach for if someone asked how to make an agent write correct code: TDD, Lean, QuickCheck, Verus, TLA+, fuzzing, mutation testing, metamorphic testing, and a lot more.

The result is a null. Nothing “really wildly outperforms,” as Luu puts it, and Default, meaning no instructions at all, scores above average. The named techniques did not help because the agents did not use them. They wrote ordinary unit tests inside a differently labeled framework and called it the technique. Formal methods were the clearest failure. Agents proved vacuous or irrelevant properties, something close to proving A implies A, and steered around the code paths that actually had bugs. Property-based testing collapsed into smoke tests and fully random inputs that mostly exercised the input-rejection path. In 63 of 160 QuickCheck runs the agent checked a single property.

TDD did the worst of the recognizable techniques, which Luu predicted before he ran the experiment. Agents wrote more tests but worse ones, and sometimes encoded the wrong behavior as the expected output. They had failing tests before any substantial implementation in 67 of 160 runs, against zero under Default. A joke condition, “Make no mistakes,” performed the same as no instruction at all, which Luu reads as evidence that the technique labels were doing near-zero work.

The wins, when they happened, came from verification done properly. Fuzzing with structured random inputs found real bugs in about half of the 10 runs that actually tried it. An audit pass had the best correctness at xhigh effort. Neither beat Default reliably. Luu’s own conclusion is the sentence I keep coming back to: “regardless of the library or technique suggested, agents failed to use the technique.”

It is easy to read that sentence as “testing is pointless.” It is the opposite. The techniques that did nothing were the ones done badly. The ones that did something, fuzzing and audit, were done with actual structure and fresh eyes. An agent does not verify just because you name a technique.

The label hides the gap

“Agentic” is doing real rhetorical work here. TradingAgents, a multi-agent financial trading framework with 103k stars and 19.9k forks, packages its verification as role-played debates between bull and bear researchers and a risk-management team that approves orders. Nothing checks whether an answer is correct. The README itself says backtest results “are not guaranteed to match any published figure” and tells you to treat it “as a research scaffold.” Even the question of which model-plus-harness combination produces a correct result gets answered by hand. A public benchmark page records each run’s duration, token counts, tool errors, and whether a human opened the output and looked at the screenshots.

That manual page is the most honest artifact in this story. It does not pretend the evaluation is automated, because it is not.

There is a one-sentence version of the gap, and it is the thesis here. “Agentic” describes the freedom to act, not the ability to be right. Autonomy, meaning loops and tool calls and self-direction, is orthogonal to reliability, and the industry is shipping the first without the second. The same models that ace verifiable math when trained on verifiable rewards cannot be trusted to check their own work once you drop them into an agent loop. Telling them the name of a technique does not close the gap. We covered Andrew Ng’s four agentic patterns, reflection among them, in the rise of agentic infrastructure. Reflection only works if the agent can actually check its own work.

What actually works

Luu’s finding on what does work points at the shape of the fix, and it is not front-loaded instructions. What works is a human who sets up a reasonable test and triage structure and then iterates. Luu writes that if you “look at what it does and type a few more sentences,” you can often get an agent to a good place quickly. That is a different picture of the human role than the one “agentic” marketing implies. The human is not the prompt-writer who names a technique and walks away. The human is the verification layer.

The strongest pushback in the Hacker News thread is worth taking seriously, because it changes where the fix lives. One commenter argues that a large share of effective testing lives in architecture, not in the test framework. Another says agents reduce TDD to a rigid ritual that never tests business behavior. The genuinely hard skill, in this view, is problem decomposition: choosing what to test, which is a design question more than a tooling question. If that is right, the verification layer is not a bolt-on test framework. It is interfaces, dependency boundaries, separable state, the shape of the code. I do not know that this fully lands, but it is the most useful correction to the naive reading that we just need agents to run more tests.

The caveats

A few limits on how far I want to push this.

Luu’s experiment is one person’s lab notebook, not peer-reviewed work. It is better than most public evals because he pre-registered predictions and disclosed the methodology, but it is still a single practitioner running a single harness with a single model. The specific ordering of techniques should not be over-read; prompting behavior shifts across model versions and harnesses, and Luu says so himself.

The eval is contrived in a specific direction. Every task was an RFC, Zstd and IMAP, which means the spec is clearer and more detailed than what a real programmer hands an agent. Luu expects the failure modes to be the same or worse on most real-world problems, not milder.

TradingAgents is a research scaffold whose authors disclaim it as investment advice. I am using it as an illustration of popularity without verification, not as evidence that multi-agent debate is worthless. The hangar-harness page is a personal blog table, an anecdote about how ad hoc agent evaluation is, not a benchmark with statistical weight. And the verifiable-reward recipe has a known boundary. R1 and o1 gained on tasks with cheap, automatic ground truth, math answers and unit tests. Whether that generalizes to open-ended tool use with side effects is an open question, and it is the substance of the gap. I am not claiming verification is solved. I am claiming it is the proven lever and the missing layer.

Bottom line

The reasoning-model jump was a verification story. DeepSeek and OpenAI both built it on checkable rewards, and the AIME gap between GPT-4o and o1 is the cleanest single number for how much that lever is worth. Agentic workflows did not inherit it. Dan Luu’s experiment shows agents cannot verify their own work even when told exactly which technique to use, because they do not use the technique. Naming verification does nothing. Doing it, with structure and a fresh pair of eyes, is the whole game.

That is a Clarion Street-shaped conclusion. The missing layer in agentic AI has never been a better model. It has been the infrastructure around the model, and this is the sharpest empirical version of that claim yet. The next frontier is a verification layer, and it will have to come from two directions. Downstream, harnesses have to build verification in structurally: the test and triage scaffolding, the fresh-context independent checks, the structured fuzzing that agents only do when a human insists. Upstream, someone has to make open-ended agentic actions verifiable the way math answers are. That is where the durable value is, and nobody owns it yet.

Agents did not inherit it

The label hides the gap

What actually works

The caveats

Bottom line

Sources