For the last few years, getting good results from a language model meant writing a better prompt. Then it meant giving the model better context: the right documents, tools and instructions. The newest shift goes one step further. Instead of steering an agent turn by turn, you design the loop it runs in.
That practice is called loop engineering: designing the control system that prompts, checks, retries and stops an AI agent, so it can work towards a goal with little hands-on supervision. It's the idea behind today's AI coding agents, and it applies to any agent you want to trust with real work.
What a loop looks like
Every agent loop follows the same basic cycle:
- Goal: a clear statement of what "done" means.
- Act: the agent takes a step, such as writing code, calling a tool or drafting a reply.
- Observe: it collects the result: output, errors, test results, a tool's response.
- Verify: something checks whether that result moves it closer to the goal.
- Adjust: the agent uses what it learned to plan the next step, or stops.
A single prompt is one pass through this cycle. A loop runs it repeatedly, and that's where both the power and the risk come from.
Verification is the heart of the loop
A loop can only be as good as its check. If the agent can't tell a good result from a bad one, more iterations just produce more confident mistakes.
Good verifiers are concrete and automatic:
- Tests that must pass. For coding agents this is the strongest signal available.
- Validators that check format, schema or business rules.
- Comparisons against a known-good answer or reference data.
- A second model reviewing the output against a written checklist. This is useful, but weaker than a deterministic check, so it works best alongside one.
When we design a loop, we usually start here: how will the system know it has succeeded? If we can't answer that, the task isn't ready for a loop yet.
Every loop needs a way out
An agent that never stops is as much a problem as one that stops too early. Build in exit conditions from the start:
- Success: the verifier passes.
- Budget: a maximum number of iterations, a time limit and a cost limit.
- No progress: stop if several attempts in a row make no measurable improvement.
- Escalation: hand over to a person, with a summary of what was tried, when the agent is stuck or about to do something risky.
Budgets are a safety feature, not just a cost control. They turn "the agent went off and did something strange for an hour" into "the agent tried five times, then asked for help".
Manage what the agent remembers
Each pass through the loop adds output, errors and notes. Pass all of it back every time and the context fills with noise; drop too much and the agent repeats its mistakes.
- Keep a short, structured progress log: what was tried, what happened, what's next.
- Summarise older iterations instead of replaying them in full.
- Store durable state, like files, tickets and records, outside the model, and let the agent read it back when it needs to.
Keep people where they matter
Loop engineering reduces the number of times a person has to step in, but it shouldn't take people out of decisions that matter. Low-risk steps can run freely; actions that are high-impact or hard to undo should pause for approval. We cover how to draw those lines in designing AI agents with a human in the loop.
A worked example: fixing a failing test
Here is a loop for a coding agent asked to fix a bug:
| Step | What happens |
|---|---|
| Goal | The failing test passes and no other tests break |
| Act | The agent reads the code and proposes a change |
| Observe | The full test suite runs |
| Verify | Did the target test pass? Did anything else fail? |
| Adjust | Feed the failures back and try again |
| Stop | All tests pass, or 5 attempts used: hand over with a summary |
None of this depends on clever prompting. The quality comes from the test suite (the verifier), the attempt limit (the budget) and the summary for the person reviewing the work (the escalation path).
A checklist for your first loop
Before putting an agent on repeat, make sure you can answer these:
- What exactly counts as done?
- What automatic check confirms it?
- What's the maximum number of attempts, time and spend?
- How does the loop detect it's stuck?
- Which actions need human approval?
- Where is every step logged for review?
Prompts still matter, but they're now just one part of a larger system. The teams getting dependable results from AI agents are the ones engineering the loop around them: clear goals, strong verification, sensible limits and a person in the right place. If you're planning an agent of your own, we'd be glad to help you design it.