The Agent Loop Has Always Been There — Memseek<br>Skip to content

Watch a capable coding agent work for a few minutes and something strange becomes obvious. The impressive part is rarely the first answer. It writes a patch, runs the tests, sees what failed, changes the patch, runs the tests again, and keeps going. The intelligence seems to come not from any single generation, but from what happens between generations.

This looks like a new way of using AI, but the loop itself is not new. A few years ago, almost every interaction with an LLM worked the same way: the model produced an answer, a human inspected it, noticed what was wrong, added missing context, changed the prompt, and tried again. We called that prompting. Architecturally, it was already a feedback loop.

The model was doing the generation, but the human was doing almost everything else. We were the verifier deciding whether an answer was correct. We were the memory carrying lessons from one attempt into the next. We were the planner deciding what to try, the world model predicting what might happen, and the stopping rule deciding when the result was finally good enough.

What we now call an agent is, in large part, an attempt to move those functions out of the human and into software. Tests can replace some human verification. Search can explore alternatives automatically. Memory can preserve what previous attempts discovered. A world model can estimate consequences before the system acts, while a controller can decide whether to retrieve more information, search another branch, ask for help, or stop.

Once you see agents this way, systems that look unrelated start to share the same shape. AlphaGo generated promising moves and searched their consequences. FunSearch generated programs and executed them to find which survived. Coding agents generate patches and let compilers and tests reject the bad ones. Karpathy’s autoresearch generates experiments, runs them, observes the result, and decides what to try next. The domain changes, but the architecture keeps returning: generate, evaluate, update, repeat.

That shifts the interesting question. For the last few years, we have mostly asked how intelligent the model is: how much it knows, how well it reasons, and how often it can produce the right answer on the first try. But an agent does not necessarily need a model that knows the right answer immediately. It needs a generator that can produce promising candidates and a surrounding system capable of discovering which candidates are actually good.

This is why coding agents are such an important example. Writing the correct implementation can be difficult, while compiling it is cheap. Finding a bug can be difficult, while running a test is cheap. If generation is expensive or uncertain but verification is cheap and reliable, the system can afford to be wrong, learn something from being wrong, and try again. A mediocre first attempt can become surprisingly useful when failure produces trustworthy information about what to do next.

And that leads to the larger claim of this essay. The foundation model is increasingly only one component of the intelligence we observe. Search determines what possibilities get explored. Verification determines what survives. World models let the system reason about consequences. Memory lets yesterday’s search change tomorrow’s behavior. Cognitive control determines how much computation a problem deserves and when the system should stop. The model is not the system anymore. The loop around the model is the system.

The surprising part is that we did not suddenly invent this architecture when we started building agents. The loop was already there. We were the loop. What is happening now is that, piece by piece, we are engineering the machinery that used to exist inside the person sitting in front of the model.

Autonomy means engineering the missing human#

In Yoko Li’s Knowing When to Stop, this surrounding machinery becomes explicit. Once an agent operates autonomously, convergence can no longer remain an implicit judgment supplied by a person; it has to be engineered into the system. That requires an observable state, a target state, actions that move the system toward it, a way to verify progress, and a rule for deciding when to stop. (a16z.news)

Seen this way, AI engineering is partly the process of moving pieces of cognition out of the human and into the machine . The important unit is no longer just the model; it is the loop.

AlphaGo showed why hard domains demand a loop#

AlphaGo is usually remembered as a neural-network breakthrough. But the network alone was not the system.

In AlphaGo Zero, the network supplied useful priors and value estimates. Monte Carlo Tree Search explored the alternatives. Self-play produced outcomes, and those outcomes became training data that improved the network. We will return to how those pieces taught one another; for now, notice the two kinds of computation working together....