Loops: How AI Agents Get Things Done, and How a World Model Rebuilds the Loop

A world model inserts a simulate-and-verify step, turning "act, then find out" into "find out, then act." The top lane commits blind; the bottom lane tries alternatives and blocks the impossible first.

What a loop is, before any of this is about AI

A loop is repeating a set of steps until some condition is met. You already run them all day.

A thermostat is the cleanest example. It checks the temperature, compares it to the target, turns the heating on or off, waits, and checks again, on and on until you leave. Cooking is a loop: taste, adjust the seasoning, taste again. Learning to park a car is a loop: turn, look, correct, look again. What every one of these shares is feedback: the result of the last action becomes the input to the next decision. That single feature, a result feeding back into the next choice, is what makes a loop more powerful than a fixed list of instructions. A recipe followed blindly can't recover from too much salt. A cook tasting as they go can.

Hold onto that: the result of one decision feeds the next. That feedback loop is the whole story, and it is where the trouble hides.

The agent loop

An AI agent is a loop with a language model sitting in the "decide" step.

Each turn goes: the agent looks at the current situation, including the result of whatever it did last; the model decides on the single next action; a tool acts, carrying that action out; and then the agent looks again. Round and round until the goal is reached or the agent gives up.

The ordinary agent loop: look at the situation, decide a step, act, and the result feeds the next turn. Powerful, but it only learns by acting.

The clearest way to see it is a coding agent fixing a bug. It writes a change (act), runs the tests (act), reads the failure message (look), works out an adjustment (decide), edits the code (act), runs the tests again (look). Five, ten, twenty times if it needs to, with no human between the steps. That relentless self-correction (using the result of each attempt to steer the next) is the loop doing exactly what the thermostat and the cook were doing. It's why an agent can arrive at a working answer that a single, one-shot reply never could.

Why the loop is such a leap

Three things fall out of running in a loop rather than answering once.

Self-correction. A mistake in one step is visible in the next, so the agent can catch and fix its own errors instead of confidently handing you the first thing it produced.

Decomposition. A goal too big for one step gets broken across many turns (gather, then analyse, then draft, then check) without anyone specifying the breakdown in advance.

Persistence. The agent keeps going until the job is done, rather than stopping at the first plausible-looking answer.

This is a genuine step-change over a system that answers and stops. It's most of what people mean when they say agents feel qualitatively different from chatbots.

Where the loop breaks

Now the trouble that was hiding in "the result feeds the next decision." The loop has two structural weaknesses, and neither is fixed by a better LLM.

First: the loop learns by acting. The only way it finds out what an action does is to do it and observe the result. For the coding agent, that's fine; running the tests is free and undoing a bad edit is trivial. But run the same loop on a decision that commits real resources, and "do it and see" means the trying happens in the real world. There's no safe place inside the loop to test the action first. The agent that reroutes a supply chain to see what happens has already rerouted the supply chain.

Second: errors compound. Because each step's output feeds the next step's input, small mistakes don't stay small; they multiply down a long chain. An agent that's right 96% of the time on any single step sounds excellent. Chain twenty-five of those steps together, each one feeding the next, and it's right end-to-end only about a third of the time. And nothing in the ordinary loop notices the drift, because there's no model of reality for the agent to check its running assumptions against. It only finds out it went wrong the way it finds out anything: by acting and observing, once it's too late to matter.

The missing step

Look closely at the ordinary loop and you can name exactly what it lacks. Between decide and act, there is no place to try the action safely. The loop goes straight from choosing an action to taking it in the world.

What would fill that gap is a model of the world you're acting on, one you can set to the current situation and then run forward under a proposed action, watching the consequences unfold inside the model instead of in reality. That object is a world model, and adding it changes the shape of the loop.

The loop a world model builds

With a world model underneath, the loop gains steps and, more importantly, changes its logic from act, then find out to find out, then act.

A world model inserts a simulate-and-verify step before acting, so the loop no longer has to break something to learn that it would break.

The new cycle: ground the question in what's true right now → propose candidate actions → simulate each one by rolling it forward through the model → compare the consequences of the alternatives side by side → verify that the chosen action is even possible, blocking anything that isn't → recommend, with the reasoning attached.

The step that matters is simulate. Instead of taking the action to learn its effect, the agent applies the action inside the world model and reads off what follows. It can try ten alternatives in the time it takes to describe them, and the real business feels none of them. The single most important sentence about this new loop: consequences are computed before commitment, instead of discovered after it.

That one change disarms both weaknesses at once. The loop no longer has to act in reality to learn; it simulates instead. And errors stop compounding unchecked, because every proposed step is tested against a model of the world before it's allowed to become the next step's starting point.

Two loops, running at different speeds

The deepest change a world model makes is that there isn't one loop any more. There are two, nested, running at different speeds.

The inner loop is fast. It's the plan-and-recommend cycle just described, run once per decision: ground, propose, simulate, compare, verify, recommend. It answers the question in front of it.

The outer loop is slow. After a decision is made and time passes, what really happened gets compared against what the model predicted would happen. The gap between prediction and reality becomes a signal, and that signal is used to sharpen the model. Act, observe, update. Then the next decision is made against a slightly better model of the world.

This is the part that "fundamentally changes" what a loop is. An ordinary agent loop only ever answers the current question; when the run ends, nothing is left behind but the answer. A world-model loop leaves behind a better model. Every decision improves the machinery that makes the next one. The version of the model that ran yesterday's decision is not the version that runs tomorrow's, and the difference between them is exactly yesterday's prediction error, fed back in.

Two loops at different speeds: a fast inner loop that plans and recommends, wrapped by a slow outer loop that checks each prediction against the real outcome and refines the model.

How the loop changes, in four lines

Here is the difference, side by side.

The loop is the unit

The loop, more than any single clever answer, is where an agent's intelligence lives: in the cycle of acting and adjusting. Which is also why the loop is the right place to fix an agent's biggest limitation. You don't make an agent trustworthy with a bigger model or a longer prompt. You change what happens inside its loop: you give it somewhere to try the action before it commits, and something that learns from every commitment it makes. That's what a world model does, and it's why the loop (not the model, not the prompt) is the thing to watch.

FAQ

What is an agent loop, in one sentence? A cycle of look, decide, act, look again, repeated until a goal is met, with the result of each action feeding into the next decision. It's what makes an agent act on its own rather than reply once.

Why do agents use loops instead of answering in one shot? Because the loop lets them self-correct (see a result, adjust), break big goals into steps, and keep going until the job is genuinely done. A one-shot answer can't recover from its own mistakes; a loop can.

What's the difference between the inner loop and the outer loop? The inner loop is fast and runs per decision: ground, simulate, compare, verify, recommend. The outer loop is slow: it compares what the model predicted against what really happened and uses the gap to improve the model, so the system improves at the next decision rather than only answering this one.

How does a world model change the loop? It inserts a simulate step between deciding and acting, so consequences are computed before commitment instead of discovered after. That removes the need to act in reality to learn, and it stops errors compounding unchecked because each step is tested against a model of the world first.

Is this just reinforcement learning? The outer, learning loop shares reinforcement learning's structure: act, observe, update. The difference is what's being modelled and improved: a causal model of how a specific business responds to decisions, used to simulate consequences before acting, rather than a policy tuned by trial and error in the environment itself.