Loops Need Proof, Not Vibes
Why "It Passed" Isn't Evidence
The industry found its word for how agents improve, the loop. What the conversation skips is the step that makes a loop trustworthy when the exit criterion is semantic and the agent underneath is nondeterministic.
TL;DR
- The industry converged on “the loop” as the unit of agent improvement; the hard part is not running the loop, it is trusting its output
- Deterministic gates (lint, tests, CI) are the easy case; the cases a business cares about have semantic exit criteria
- A single pass is not signal: the probability of passing all of N independent runs is p^N, decreasing in N, so “it passed” proves less the more rigorous you are
- A single end-to-end score hides which stage of a multi-stage pipeline actually broke
- An agent’s self-report of success is generated by the thing being evaluated; it is not independent evidence
- The loop was never the hard part. Trusting it was
The word of the season
The industry found its word. Devrel channels, infrastructure vendors and model vendors are all, in the same season, describing how agents get better at a task as some form of loop: run, verify, feed the result back, repeat. Some reject the term and rename it, some build taxonomies on it, some map it onto product commands. The convergence itself is the signal: closing an agent’s feedback loop has become the thing worth naming.
This essay is not about any of those framings. It is about the step all of them treat as a given: the moment a verification signal becomes a change that sticks.
Running a loop is cheap. Trusting what comes out of it is the actual engineering problem, and it is being skipped.
The easy case is not the interesting case
Where the exit criterion is deterministic, the problem mostly dissolves. A linter fails or it does not. A test suite is green or it is not. Control can route on that signal all day, and the standard advice, prefer deterministic criteria wherever they exist, is correct.
But the cases a business actually cares about rarely have one. Did this answer satisfy the user’s intent? Is this ticket actually resolved? Is this document compliant? The exit criterion is semantic: a judgment call. And the thing making the judgment call, another model, is not more trustworthy by construction than the thing being judged.
That is the regime where “the loop ran and it passed” quietly stops meaning anything, in three concrete ways.
Three ways “it passed” lies to you
A single pass is not signal. An agent that is not perfectly deterministic has run-to-run variance on anything harder than a lookup. Grade it once and you have a sample of one. Run it N times independently and demand that all N pass, and the probability of that happening by chance is p^N, where p is the true per-run pass probability. That function is decreasing in N: the more rigorous you are about sampling, the harder “it passed” becomes to achieve on the same underlying quality. A team that only ever runs once will always look better on paper than a team that is actually measuring.
Treat a single green run as proof and you have measured your luck, not your system.
A single end-to-end score hides where the pipeline broke. Any pipeline with more than one stage capable of independent failure can produce the same failing final score from different root causes. A retrieval stage that misses good candidates and a filtering stage that wrongly rejects them both show up as the same low recall in the final answer. Fix the visible symptom without decomposing by stage and you will chase the wrong cause, patch a fixture instead of a defect, or fix one stage in a way that quietly breaks another.
Verification that only checks the final answer cannot tell you which of your agents is wrong.
An agent’s self-report is not independent evidence. A model’s account of whether it succeeded is generated by the same process being evaluated. It is a hypothesis about the world, not a measurement of it, a pattern I keep meeting in fleet operations too. This applies equally to a self-improvement loop that claims a prompt change made things better: the claim needs a source of truth outside the agent making it, and a decision to merge needs a point where a human looks at the evidence before it becomes permanent.
A claim of success from inside the loop is input to verification, never a substitute for it.
Make it concrete: an agent judges whether candidate results satisfy a fuzzy natural-language criterion. Judge each case once, and a lucky sample is indistinguishable from a real fix. Judge each case five times and take the floor, and the math above stops being abstract: it is the difference between a dashboard that reads 100% and a number you can act on.
Why this isn’t a phase you graduate out of
It would be convenient if this were scaffolding for weaker models, relaxable as capability improves. The evidence points the other way: raw capability and behavioral reliability are separate axes, and the second does not reliably track the first. A more capable model can still overreach on scope, or fail in a subtly different way than its predecessor, not a strictly smaller one.
That decoupling deserves its own essay. The short version is enough here: if judgment and capability do not compound together, then the structure built to catch bad judgment is not training wheels. It is permanent infrastructure, whichever model sits underneath.
The loop was never the interesting unit
None of this is an argument against loops or against the tooling being built for them. It is an argument about what actually needs engineering, one level up from where the current conversation stops.
The interesting unit is the discipline that makes a loop’s output trustworthy before it changes anything: sampling instead of trusting a single run, decomposing verification by stage instead of trusting one score, and keeping a human at the point where an unverified claim would otherwise become permanent. It is the same discipline a supervisor plane needs when the agents are writing code instead of answering queries. The domain changes. The discipline that makes it safe to scale does not.
Key Takeaways
- The industry named the loop; nobody is showing how to close it safely when the exit criterion is semantic
- A single passing run is a sample of one; all-of-N passing has probability p^N, decreasing in N, so rigor makes “it passed” harder to claim, not easier
- Decompose verification by pipeline stage, or one end-to-end score will hide which stage regressed
- An agent’s self-report of success is a hypothesis, not a measurement; verify outside the loop and gate merges on human review
- Judgment reliability and raw capability are separate axes; the structure that catches bad judgment does not get to retire
- The loop was never the hard part. Trusting it was
Authored by Davi Guides
Visit daviguides.github.io for more insights