The engine’s failure modes,
and the loop

By the end of today you can

Four objectives

1. Describe the function-calling exchange and point to the one step where side effects happen
2. List the six engine failure modes and name the engineering remedy for each
3. Derive compounding error, pⁿ, and its three levers
4. Implement the four-part minimal agent with a scripted model client and a mandatory budget

Prompting fundamentals, in one slide

In an agent, no one types the final prompt

• Enforceable constraints beat adjectives: “three to five sentences”, not “keep it short”
• Few-shot examples fix the shape, not the reasoning
• “an instruction is a request, not a guarantee”

Sketch the parser before the next slide

Three runs, three correct answers

Name: Ada, Total: $42
The customer is Ada Lovelace and she spent forty-two dollars.
Happy to help! Ada's order total is $42.00 (invoice #1041).

• Every line is right as prose; no single parser handles all three
• Tomorrow brings a fourth phrasing: “A program cannot consume possibilities.”
• It needs a contract: JSON, with its shape pinned by a schema

Chapter 2, “Structured Output and Function Calling”

Two grades of guarantee that sound alike

Asking vs constrained decoding

“A schema, misused, makes fabrication easier to consume, not rarer.”Chapter 2 · a guarantee about shape says nothing about truth

Function calling · where does anything happen?

The model proposes; your code disposes

• “Every side effect in the system happens at step 3, inside ordinary code you wrote”
• Two model calls at minimum: the result goes back to the model, not to the user

All the model will ever know about a tool

Name, description, argument schema

name:        create_ticket
description: Open a support ticket.
             Use when the user reports
             a problem that needs human
             follow-up.
arguments:   { title:    string,
               severity: one of
                 "low" | "med" | "high",
               body:     string }

Chapter 2 · pseudocode, as in the book; each vendor’s syntax differs

Failure mode 1 · the master symptom

Hallucination: fluent, confident, wrong

• Lacking the fact, the machinery writes the most plausible string where the fact should be
• “Tone carries no information about truth”
• Snowballing: once a false claim is in the transcript, later text elaborates on it

“language models are optimized to be good test-takers, and guessing when uncertain improves test performance.”Kalai et al., “Why Language Models Hallucinate” (2025), quoted in Chapter 2

Failure mode 2 · the jagged frontier

Respond with engineering, not sterner prompts

Six failure modes, six remedies

Chapter 2, “Limitations and Failure Modes” · properties of current models; verify where yours stand

The master entry, now defended

Reliability multiplies: pⁿ

0.95²⁰ ≈ 36%

0.92³⁰ ≈ 8%

• Independence is the optimistic case
• Errors land in the transcript and condition every later step

“Per-step accuracy is a ceiling, not a forecast.” · Chapter 2

Three levers

Levers from Chapter 2 · the worked numbers are illustrative algebra from a 95% × 20-step baseline (36%), assuming a check that always catches a failed step

In class · pairs · 15 minutes

How reliable must each step be?

1. Watch: Why errors compound (3 min explainer)
2. Open aiagentsengineered.com/tools/compounding-error-calculator/
3. Target 90% end to end over 20 steps: find p*, the per-step reliability you need
4. At 95% per step, what is the longest chain that still meets 90%?
5. Pick the cheapest lever for a task of your choice, and defend it in two sentences

Runs in the browser · no account, no API key · copy the result as Markdown to submit

Observe · reason · act · observe the result

Four beats to a pass

• Agents “are typically just LLMs using tools based on environmental feedback in a loop” (Schluntz and Zhang, quoted in Ch. 3)
• The model supplies one beat; your code supplies the other three

The index card · Chapter 3, “The Loop”

history = [standing_instructions, user_goal]

repeat up to MAX_STEPS times:
    response = model(history)              # reason over the desk
    if response is a final answer:
        return response.text               # stop: the model judges it done
    result = execute(response.tool_call)   # act: your code runs the tool
    append response.tool_call to history   # record what the model did
    append result to history               # record what the world said back

return "stopped: step budget exhausted"    # stop: the safety net

• “you wrote the loop; the model writes the path”
• The two appends are the agent’s only memory
• No branch mentions tests, files or checkouts
• Drop the result: the model asks again, forever

ReAct: interleaving reasoning and acting

Why one small step at a time?

• Plan up front, then execute blindly: “all of its judgment at the point of maximum ignorance”
• Reasoning alone: a sealed room; it elaborates a fabrication
• Acting alone: a sleepwalker; it repeats gestures
• Interleave: thought, action, observation. Grounding “is a schedule”

A minimal agent from scratch

Four parts inside a harness

1. Model client: sends messages and tool definitions; stateless
2. Tools: name, description, schema, and the function that runs
3. Message history: the run’s entire memory
4. The loop: ties the three together

“An agent, in one line, is a model plus a harness.”Chapter 3, “A Minimal Agent from Scratch”

Worked example · Appendix A

Under seventy lines, no magic

function execute(call):
  if call.name not in TOOLS:
    return result(call.id,
      error: "no such tool: " + call.name)
  outcome = try TOOLS[call.name].fn(call.arguments)
  if the call failed:
    return result(call.id,
      error: plain_description(outcome))
  return result(call.id, outcome)

• “Three cases, one policy: everything becomes a result.” The id ties each result to its request
• Tools: list_files, read_file, edit_file · MAX_STEPS = 20, illustrative

Appendix A · goal: change ‘Hello’ to ‘Welcome’

Watch the history grow

“Your program is dumb on purpose; the transcript only looks smart.”

Stop conditions and budgets

Three exits, ranked by trust

• Verified check: suite green, file parses. “The model’s ‘done’ is testimony; a green test is evidence.”
• Budget: steps, tokens, time, money; mandatory, set first. Fires? Fail loudly, save the transcript
• Errors: can the model act on it? Feed it back. Evidence the run is off the rails? Halt

How you will test the harness · Chapter 15

Replace the model with a script

SCRIPT = [ call list_files(),
           call read_file("greetings.py"),
           call edit_file(...),
           call read_file("greetings.py"),
           say  "Done. GREETING now 'Welcome'." ]

function scripted_send(request):
    # replaces provider.send
    return next response in SCRIPT

Lab pseudocode, not from the book; the testing approach is Chapter 15’s

The day-one question

Shouldn’t I just use a framework?

Recap

Five things to keep

• The model proposes; your code disposes. Side effects happen only in your code
• A schema guarantees shape, never truth: validate the content
• Six failure modes; each answered by engineering, not sterner prompts
• pⁿ is the optimistic case; shrink n, raise effective p, checkpoint
• An agent is a model plus a harness: four parts, a loop, three exits, a budget first

Before next week

Lab 1 and reading

This week’s reading: Ch. 2 §4–6 (free) · Ch. 3 · App. A (full book)