The Map of Loop Engineering

You already have a loop. This course is about engineering it. First, the territory.

You’ve written the thing already: a while loop that calls a model, runs the tool calls it asks for, feeds the results back, and goes again. Thorsten Ball’s famous one-liner is that an agent is just “an LLM, a loop, and enough tokens”1 — and he’s right that the skeleton is ~300 lines of boilerplate.

Loop engineering is everything that happens after that skeleton works. The gap between a toy loop and an agent you’d put in front of a customer is not a flash of genius — it’s a handful of levers, each tuned deliberately. This lesson is the map of those levers. Every later lesson zooms into one.

One turn, anatomised

Before the map, fix the unit. Loop engineering operates on the turn — one pass through the loop. Strip a turn to its bones and it’s the same six moves every time:

1. Assemble context — build the exact token payload the model will see this turn (instructions + state + history + tool defs).
2. Call the model — one inference. It returns either an answer or one-or-more tool calls.
3. Parse the output — tool calls are “just structured outputs,” routed by code you control.2
4. Execute tools — run them against the real world; capture results and errors.
5. Append the observation — fold those results back into state. This is the ground truth that lets the agent steer.3
6. Check the stop condition — done? out of budget? hand to a human? Else: back to step 1.

HumanLayer compresses the whole apparatus to “prompt + switch statement + context builder + loop.”2 Memorise that phrase — every lever below is a way of engineering one of those four words.

Here are those six moves as the code you’ve already written, stripped to its spine. Notice there’s no magic — the “agent” is this loop:

# Factor 8 — own your control flow: this loop IS the agent
state = init(task)
for turn in range(MAX_TURNS):                  # move 6 · stop: budget guard
    ctx     = build_context(state)             # move 1 · assemble context
    reply   = model(ctx)                       # move 2 · call the model
    if reply.is_final:                         # move 6 · stop: goal reached
        return reply.answer
    calls   = parse_tool_calls(reply)          # move 3 · parse output
    results = [run(c) for c in calls]          # move 4 · execute tools (+ errors)
    state   = append(state, results)           # move 5 · append observation
raise BudgetExceeded(state)                    # move 6 · stop: guard tripped

Every lever in this course is a way of engineering one of those lines: build_context is Lever 02, run and its tools are Levers 03/04, MAX_TURNS is Lever 05, the handling of errors inside run is Lever 06, and state is Lever 07. The shape of the loop itself is Lever 01.

The seven levers

This is the map. Each card is a dimension you engineer independently. You won’t master them today — you’ll learn to see them, so when an agent misbehaves you know which knob to reach for.

The one distinction that organises the map

If you remember one thing, remember Lever 01. Anthropic draws the line cleanly:

Workflows are systems where LLMs and tools are orchestrated through predefined code paths.
Agents are systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks. — Anthropic, Building Effective Agents

This isn’t a binary you pick once — it’s a dial per decision. Most production “agents” sit far toward the workflow end: mostly ordinary, deterministic software with the model placed at a few high-leverage decision points.2 Anthropic’s blunt advice: “add complexity only when it demonstrably improves outcomes.”3 The five named workflow patterns — chaining, routing, parallelization, orchestrator–workers, evaluator–optimizer — are all points on the workflow side of this dial. We’ll dedicate a lesson to them.

Recall check

Don’t re-read — retrieve. Effortful recall is what turns this map into memory you’ll still have next week. Answer from your head; feedback is instant.

Sources

1. Thorsten Ball — How to Build an Agent (ampcode.com). “An LLM, a loop, and enough tokens.”
2. HumanLayer — 12-Factor Agents. Factors 8 (own control flow), 9 (compact errors), 10 (small agents, 3–20 steps).
3. Anthropic — Effective Context Engineering for AI Agents.