Learning objectives
By the end you can:
- Explain the plan → act (with tools) → observe → repeat loop that defines an agent, and distinguish it from a single-turn chat answer and a simpler retrieval-grounded (RAG) answer.
- State mechanically why each step's output becomes the next step's input, and explain why a single early error compounds, and typically becomes more confidently stated, not less: across a multi-step chain.
- Apply a three-axis test (multi-step? tool-using? repetitive with per-step verifiability?) to judge whether a candidate task is a good fit for an agent-style workflow or should stay a human judgment call.
- Name the recurring situations in which an agentic workflow quietly compounds error (unverified long chains, judgment-heavy tasks with no ground truth, irreversible actions, untrusted tool content) and explain the mechanism behind each.
- Design mandatory human-in-the-loop checkpoints for a workflow: exactly where they must sit, what each one checks, and what happens on reject.
- Explain why tool output must always be treated as untrusted data and never as an instruction, and identify the seam where prompt injection enters an agent loop.
- Use a structured, reusable, seven-part template to specify a lightweight, checkpointed analyst workflow for a real task, its steps, tools by category, checkpoints, stopping condition, and single most likely failure mode.
- Estimate, with explicit and stated assumptions, whether a candidate agent workflow is genuinely net faster than doing the task by hand once verification time is honestly included.
- State plainly what this module does not teach (writing and running real agent code) and where that skill lives in this program.
Prerequisites & connections
Builds on. AI0.01's mechanics are load-bearing here, not background trivia: because an agent is still, at every step, the same next-token predictor generating the most plausible continuation of its context, it can be exactly as fluently wrong inside a five-step loop as in a single chat reply, this module's entire compounding-error mechanism is a direct consequence of the payoff line from AI0.01, the model optimizes for plausible, not true, applied recursively. AI0.03's structured-prompting discipline (Role · Context · Task · Format, asking for citations and uncertainty) is exactly what the "Plan" half of the loop below is made of, an agent's internal reasoning step is a prompted call like any other, just one the system runs on itself. AI0.04's retrieval pattern is what most "Act, then Observe" pairs turn out to be under the hood: a tool call that searches or fetches, and an observation that is a retrieved chunk of text. If any of those three feel shaky, this module will expose it fast, because nothing here works without them: go back before going forward.
Feeds forward. AI0.06, the crown module of this branch, takes several of the failure mechanisms introduced here (compounding hallucination across steps, and prompt injection specifically) and drills them to reflex with red-team, planted-error exercises; the five-check Guardrail defined here is the same one AI0.06 crowns. AI0.07's capstone asks you to run a verified pass across your real work (research, modeling, memos, decks, code, data) and some of those passes will legitimately be multi-step workflows, made safe by the discipline built here. This module also touches the program's oldest working agreements: the decision journal (agreement 6) is where a checkpoint's approve/reject decision belongs, and process-over-outcome (agreement 8) is why a workflow is judged by its checkpoint design, not by whether one run happened to come out right.
The one explicit boundary. This module teaches the judgment layer only: when to build a workflow like this, how to shape it, and where it must be gated, it stops at a paper design. Actually writing the code, calling a search or file-read API, handling a failed call, retrying, logging every step, testing against hidden cases so it cannot be quietly wrong, is real software-engineering skill, and it belongs to this program's quant, data, and programming region, built on top of the judgment this module gives you. If you are itching to open an editor while reading this, channel it into designing the workflow precisely enough that whoever eventually codes it cannot get the judgment calls wrong, even if the syntax is not yours to write.