The Loop Around the Model

A good part of my career has been spent around loops that never sleep. Autoscalers that watch load and quietly add capacity. Reconcilers that compare what a system should look like against what it does, and fix the drift. Retry workers that observe, decide, act, and go around again. So the first time I read a full agent transcript – a goal at the top, tool calls in the middle, a stop at the bottom – I did not see a new species. I saw the oldest machine in operations with one part swapped out. The part that decides.

Stage 04 is where the Route plants its flag: we are here, 2026. It is also where the vocabulary gets loudest – agentic, autonomous, orchestrated – and the mechanics get explained least. This piece is the floor under the vocabulary. Not what agents need in production; that is Chapter 5's territory, and it assumes you know what you are building. This is the thing itself.

Three Beats and a Goal

Strip every framework away and an agent is a small program you could sketch on one whiteboard: take a goal, then go around a loop until something ends it. The Route names the beats think, act, observe, and each one is load-bearing.

The beats are not new machinery, and that is the point of this whole shelf. The think beat reads a context window you already know how to ration; the act beat fires through the tool contracts of the previous stage; the observe beat is just the result entering the window as one more claimant. What the loop adds is repetition with consequences: each pass changes the world a little, and each change shapes the next decision. The frameworks – graphs, chains, orchestrators – are furniture around this cycle. The Route says the loop matters more than the library, and this is the loop.

What Makes It an Agent

The industry burned a year arguing about the word and settled, sensibly, on a line an architect can actually use: it is about who owns the control flow. In a workflow, you write the steps and the model fills in the blanks – powerful, predictable, and not an agent. In an agent, the model picks the next step itself. That single transfer of control is the entire difference, and it is less a binary than a dial:

Two things follow from seeing autonomy as a dial. First, you should hold position on it as long as you can: a workflow that solves the problem beats an agent that usually does – the same cheapest-move-first rule the Route applies to everything. Second, moving right on the dial is not a decision you make once in an architecture diagram; it is trust, extended one notch at a time, on evidence. What that evidence looks like is Stage 05's whole subject.

You Have Run This Loop Before

Here is the reading that made agents click for me, and for every operations-minded engineer I have walked through it. Infrastructure has run watch-decide-act loops for decades: the autoscaler that compares load against a threshold and adds capacity; the reconciler pattern Kubernetes made famous, forever comparing desired state against observed state and issuing corrections; the self-healing controller that notices drift and undoes it. Line the two machines up and the correspondence is not loose metaphor. It is one to one:

One cell in that table changed, and it is worth staring at. A reconciler runs a policy you wrote: every branch enumerated, every response deterministic, reviewed line by line before it ever touched production. An agent runs a policy it infers – fresh, every turn, from whatever is in the window. That substitution buys the thing no reconciler ever had: generality, the ability to handle situations nobody enumerated. And it bills you in the three currencies operations people respect most: determinism (the same input may not produce the same plan), boundedness (the action space is as wide as the tool belt), and cost per iteration (every turn runs the meter). Everything difficult about agent engineering is compensation for that one swapped part.

Why Loops Run Away

Old loops ran away too – ask anyone who has survived a retry storm – but they ran away in ways you could enumerate. Agent loops add three failure shapes of their own. Motion without progress: the loop keeps acting, but no observable state moves toward the goal; the question a runaway can never answer is what changed since the last turn? Compounding error: a wrong observation feeds a worse decision, which produces a stranger action, and the transcript drifts somewhere no single step chose to go. And the unfalsifiable goal: hand a reconciler a desired state it can never verify – make it better, clean this up – and it will reconcile forever, at your expense.

The defenses are unglamorous and identical in spirit to the ones you already run: a progress check that compares state, not activity; tool results treated as inputs to validate rather than truths to absorb; goals written like acceptance criteria, with a testable done; and budgets – turns, tokens, time, money – as first-class citizens of the design rather than a panicked patch after the first incident. Chapter 5 puts a dollar figure on what unbounded loops become; the mechanical version is simpler. A loop without a budget is not autonomous. It is unsupervised.

The Transcript Is the Memory

Within a single run, an agent's memory is nothing exotic: it is the transcript itself, accumulating in the context window, turn after turn – which means everything the payload contract taught applies mid-loop: long runs must compress their own history, prune dead branches, and keep the goal near the model's attention. What survives after the run – working state, summaries, preferences that persist across sessions – is a separate discipline with separate failure modes, and it gets its own dive on this shelf. So does the catalogue of moves a loop can make: reflection, planning, routing, delegation. Floor first; furniture later.

Easy to Start, Hard to Deploy

Chapter 5 opens from the deployment side of this exact door: an agent is easy to start and hard to deploy safely. Now you can see why both halves are true. Easy to start, because the machine is three beats and a goal – a loop you could build this afternoon. Hard to deploy, because one part of a fifty-year-old pattern was swapped for something brilliant and unbounded, and every fence, budget, and checkpoint that production demands exists to hold that one part. The loop was never the hard part. The hard part is the same as it has been for every control loop since the first thermostat: deciding how much rope, and holding the other end.