Loop engineering: stop prompting your AI, start designing the loop
For a few years the skill everyone chased was writing the perfect prompt. Then, in mid-2026, a single idea reorganised how a lot of people work with AI: stop prompting your agent by hand, and design the loop that prompts it for you. Instead of typing instruction after instruction, you hand the agent a goal and a cycle, and let it drive itself toward that goal. That practice has a name — loop engineering — and it is quickly becoming the core skill of building agents.
What loop engineering actually is
Prompt engineering optimises the words in a single message. Loop engineering optimises the cycle: the agent takes an action, observes what happened, reasons about it, and chooses the next action — over and over — until the goal is met or a stop condition trips. The shift is subtle but profound. You stop being the one in the loop, hitting enter again and again, and become the one who designs the loop.
The idea is older than the hype: meet ReAct
The intellectual ancestor here is ReAct (Reason + Act), from research at Princeton and Google, which interleaved reasoning steps with action steps. It showed something that now feels obvious: a model that observes the result of each action before taking the next one behaves completely differently from one that answers in a single shot. That rhythm — reason, act, observe, repeat — is the beating heart of every agent loop.
Anatomy of a loop that converges
A good loop is much more than "call the model again." Four ingredients decide whether it makes progress or just spins:
- A checkable goal — not "be helpful" but a concrete target the loop can test against.
- An action space — the tools the agent may use on each turn.
- Real observations — genuine feedback from the world (a test result, a query output, an error) fed back into the next turn.
- A termination condition — how the loop knows it is done, or that it should stop trying.
# loop engineering: drive toward a goal, with a stop condition for step in range(MAX_STEPS): action = agent(goal, context) # decide the next move result = run(action) # act in the world context = observe(context, result) # feed the result back in if goal_met(result): # the part people forget break else: escalate("no progress within budget") # stop, don't spin
Where loops go wrong
Most failed agents are really failed loops. The classic ways a loop breaks:
- No stopping criteria — the agent loops forever, or quietly burns your budget.
- No progress signal — it repeats the same failing action, never noticing it is not working.
- Weak observations — it acts half-blind because the result of the last action never made it back into context.
- A vague goal — with nothing concrete to check, the loop cannot tell success from spinning.
A simple discipline prevents most of this: every iteration should either make measurable progress toward the goal or trip a limit. If it does neither, the loop should stop and ask a human rather than grind on.
Loop, context, harness — how the layers fit
These ideas are layers, not rivals. Prompt engineering is the words you send. Context engineering is everything the model sees each turn. Loop engineering is the cycle that drives the agent. And the harness is the whole system around the model that runs all of it — as we covered in why the model is the smallest part of an AI agent, the harness runs the loop, not the model. Loop engineering is simply how you make that loop converge instead of wander.
This is the quiet shift from using AI to engineering with it. If you are building an agent that has to run against a goal rather than a single prompt — a coding agent, a research agent, an automation that works unattended — loop design is where its reliability comes from. That is exactly the kind of system we build and harden for production.