4.4 KiB

Raw Permalink Blame History

Agent Loops: The Complete Guide

June 15, 2026

Every agent is a loop. The difference between a demo agent and a production agent is how well you control that loop.

The Three Loop Types

Type 1: Think → Act → Observe (Basic)

1. LLM decides what to do next (thinks)
2. Tool executes the decision (acts)
3. Result feeds back to LLM (observes)
4. Repeat until done

This is the simplest loop. Every lab in this course starts here. It works for single-step tasks where the agent calls one tool and returns an answer.

Problem: No bounded iteration. Without MAX_ITERATIONS, the agent loops forever on ambiguous tasks.

Type 2: Plan → Execute → Verify (Guarded)

1. Agent plans the approach (tool selection + sequence)
2. Agent executes each step
3. Verifier agent checks each result
4. On failure: re-plan with new context
5. On success: proceed or terminate

The verifier is a second, simpler agent (or the same agent with a verification prompt) that checks output quality before the loop continues. This prevents the agent from confidently proceeding with wrong results.

Type 3: Cascade (Multi-Model)

Step 1: Haiku (cheap) — bulk processing
  → Step 2: Sonnet (mid) — analysis
    → Step 3: Opus (premium) — synthesis, quality check

Each step uses a different model tier. Early steps are cheap and fast. Later steps are expensive but thorough. The cascade loop saves 60-80% on token costs compared to running everything through Opus.

Termination Conditions

Every loop needs at least one termination condition. Production loops need three:

1. Content-Based Termination

The agent decides it's done:

if response.stop_reason == "end_turn":
    return response.text  # Normal completion
elif response.stop_reason == "tool_use":
    continue_loop()  # Agent wants another turn

2. Hard Limit Termination

The loop has a maximum iteration count:

MAX_ITERATIONS = 10
for i in range(MAX_ITERATIONS):
    result = agent_step()
    if result.is_done:
        return result
return {"error": "Max iterations exceeded", "partial_result": result}

This is non-negotiable in production. Every lab includes it. Without it, a single bad prompt can cost you $50+ in runaway token usage.

3. Cost Budget Termination

The loop tracks cumulative cost and stops when the budget is spent:

BUDGET_CENTS = 50
total_cost = 0

for i in range(MAX_ITERATIONS):
    result = agent_step()
    total_cost += result.cost_cents
    if total_cost > BUDGET_CENTS:
        return {"error": "Budget exceeded", "total_cost": total_cost}
    if result.is_done:
        return result

Loop Anti-Patterns

Grinding

The agent runs the same code repeatedly hoping for a different result:

# BAD: no change between iterations
for i in range(100):
    score = evaluate(agent_config)
    if score > best_score:
        best_score = score  # same config, different random seed

Fix: Hash the agent configuration. If it hasn't changed, don't re-run.

Hallucination Cascade

Each loop iteration builds on potentially wrong information from the previous step. By iteration 5, the agent's context is full of hallucinated facts, and it makes reasonable-looking decisions based on nonsense.

Fix: A verifier step after every tool call checks factual claims before they enter the context window.

Infinite Loop by Design

Some tasks naturally loop (monitoring, polling). Without careful budgeting, these can run forever:

# BAD: no cost tracking on long-running loops
while True:
    data = check_api()
    if data.alerts:
        send_notification(data.alerts)
    time.sleep(60)

Fix: Daily cost budget + max iterations even in "infinite" loops.

The 5 Rules of Production Loops

Always set MAX_ITERATIONS — even in loops you expect to terminate naturally
Always track cost per iteration — you can't optimize what you don't measure
Always verify intermediate results — don't let bad context compound
Always have a fallback — what happens when max iterations is reached? Return partial results, don't crash
Always log the loop — every iteration should be recorded for debugging

This is adapted from Module 1: Foundations of the Agentic Engineering the Hard Way course. Full course includes 65 lessons, 13 labs, and 20 skill kits.

4.4 KiB Raw Permalink Blame History