An Agent With No Feedback Is Running Open-Loop

Control engineers have a distinction I keep borrowing for AI work: open-loop versus closed-loop. An open-loop controller acts and hopes — it sends a command and never looks at what actually happened. A closed-loop controller measures the result and feeds it back, correcting each cycle. Most disappointing AI agents are open-loop. They generate, they act, and nothing external ever tells them whether it worked. The fix that turns a clever demo into something that reliably converges isn’t a better model. It’s closing the loop with feedback that comes from reality.

Fire-and-hope doesn’t converge, it drifts

An agent that produces output and moves on has no error signal. It can’t tell a good result from a plausible one, because nothing is measuring the difference. Run that in a loop and it doesn’t home in on the goal — it wanders, which is exactly the random-walk failure mode that kills unattended loops. Each step looks fine on its own; the trajectory goes nowhere. Without feedback, “iterate until it’s right” quietly becomes “iterate until you run out of budget.”

The model grading itself is not feedback

The tempting shortcut is to let the agent evaluate its own work. Ask it “is this correct?” and it’ll happily say yes. That’s not a verifier; it’s the same model that produced the answer, marking its own homework, and it passes itself every time. Any blind spot in the generation is a blind spot in the evaluation, because they’re the same mind.

A model reviewing its own output is a defendant serving as their own jury. You need a witness that isn’t the accused.

Grounded feedback means the signal originates outside the model — a compiler, a test run, a type checker, a benchmark, a linter, a schema validator. It corrects the model instead of echoing it, because it doesn’t share the model’s assumptions. That external origin is the whole point: the verifier can say “no” in a way the agent can’t rationalize.

A verifier has to be a hard rule, not a vibe

The signal is only as good as its objectivity. “The output should look professional” is a vibe, and an agent will satisfy a vibe by convincing itself. “The note must contain at least two links that resolve to real files,” “the code must compile,” “the test named X must pass,” “the JSON must validate against this schema” — those are hard rules. Either they hold or they don’t, and no amount of confident prose changes the answer.

This is the same discipline I lean on outside of AI entirely, in “it ran” is not “it worked”: a single self-reported success signal is the easiest one to fool yourself with, so you demand a check that would actually go red when the thing is broken. An agent loop just makes it non-optional, because there’s no tired human in the loop to feel the uncertainty.

The verifier defines “done”

Once the feedback is real, it does double duty: it also tells the loop when to stop. “Repeat until the test passes.” “Repeat until no further speedup.” “Repeat until the validator is clean.” The stopping condition falls out of the verifier for free, and it’s a condition the agent can’t fake its way past. Compare that to an open-loop agent, which stops when it decides it’s done — which is to say, whenever it feels like it.

The strongest setups actually use two kinds of grounding together: a tool-based check (the compiler, the tests — objective but narrow) and, where it helps, a second agent as a reviewer (broader, but less objective, since two models can share a blind spot). The tool is the floor you never go below; the reviewer catches things the tool doesn’t think to look at.

Close the loop before you scale it

So before I let an agent run on anything that matters, the first question isn’t “which model?” It’s “what’s the external signal that tells this thing it’s wrong, and can it argue with that signal?” If the answer is “it decides for itself,” I’ve built an open-loop controller and I should expect it to drift. If the answer is a check that goes red on its own terms, I’ve got something that can actually converge. That closed loop — act, measure against reality, correct, repeat — is the backbone of how I run the AI automation lab, and it matters more the less I’m watching. If you’re wiring feedback into your own agent loops and want to compare what counts as a trustworthy signal, I’m easy to reach.