The map

1. The shape of the twelve stages

Think of the course as four layers, each built on the one below it.

              ┌────────────────────────────────┐
   Layer 4    │  Ship + Survive in Production  │   Ch 9, 10, 11, 12
              │  obs, security, deploy, OSS    │
              └────────────────────────────────┘
                            ▲
              ┌────────────────────────────────┐
   Layer 3    │       Make it Trustworthy      │   Ch 7, 8
              │       HITL, evals              │
              └────────────────────────────────┘
                            ▲
              ┌────────────────────────────────┐
   Layer 2    │       Make it an Agent         │   Ch 3, 4, 5, 6
              │  tools, memory, loops, swarms  │
              └────────────────────────────────┘
                            ▲
              ┌────────────────────────────────┐
   Layer 1    │        Foundations             │   Ch 1, 2
              │   async Python + LLM basics    │
              └────────────────────────────────┘

Each layer assumes the one below is fluent. You can skim a chapter you already know, but don't skip one whose vocabulary you can't reproduce on a whiteboard.

2. The twelve stages, one line each

Stage	Chapter	What it installs
1	Ch 1	asyncio, FastAPI, event-driven flow, error contracts, API integration
2	Ch 2	How LLMs actually fail. Context, routing, tokens, latency, failure modes
3	Ch 3	Tool calling, structured outputs, Pydantic, error recovery (Capstone 1)
4	Ch 4	Short-term + long-term memory, compression, cross-session sync (Capstone 2)
5	Ch 5	ReAct, plan-and-execute, reflection, iteration limits (Capstone 3)
6	Ch 6	LangGraph/CrewAI, supervisors, message passing, handoffs (Capstone 4)
7	Ch 7	Uncertainty detection, approval gates, audit, resume logic
8	Ch 8	Eval harnesses, LLM-as-judge, regression, hallucination (Capstone 5)
9	Ch 9	LangSmith/Arize tracing, cost dashboards, latency, alerts
10	Ch 10	Prompt injection, output filter, PII, sandbox, compliance (Capstone 6)
11	Ch 11	vLLM/SGLang, k8s scaling, CI/CD for agents, canary, rollback
12	Ch 12	Open source, architecture writeups, demo recordings (Capstone 7)

3. Where to start, by where you already are

• "I've barely touched async Python." Start at Ch 1. Don't skip the FastAPI unit — every agent in this course is a FastAPI service.
• "I'm fluent in Python but new to LLMs." Skim Ch 1, settle in at Ch 2. The LLM failure-mode taxonomy will save you months.
• "I've called an LLM API but never built a tool-calling loop." Skim Ch 1–2, settle at Ch 3. Capstone 1 is the smallest real agent.
• "I've built a tool-calling agent but I'm tired of it forgetting things." Jump to Ch 4. Memory is your bottleneck.
• "I've shipped a single-agent thing and want to learn multi-agent." Read Ch 5 fast for the loop discipline, then go to Ch 6.
• "I've built agents but they explode in production." Skip to Ch 7–10. Trust, evals, traces, guardrails. This is where careers are made.
• "I want to be hireable / build a portfolio." Read every chapter, ship every capstone, then Ch 12 turns the work into a resume.

4. The capstones, in order

The seven capstones aren't side quests. They are the spine of the course. Each one re-uses the previous one's repo as a starting point. By Capstone 7, you've evolved a single codebase from a one-tool script into a deployed, observed, secured, multi-agent system with a public README.

Capstone 1  →  Capstone 2  →  Capstone 3  →  Capstone 4
toolbot       memo            scholar         review crew
   ↓
Capstone 5  →  Capstone 6  →  Capstone 7
eval harness   hardened        portfolio drop
               support

If you want to keep them separate repos, fine — but don't skip them. The capstones are where the unit lessons stop being abstract and become muscle memory.

5. What you don't need to start

Things you do not need before Chapter 1:

• A GPU. Almost everything runs on a hosted API. The local-model unit in Stage 11 is the only place a GPU is even discussed, and there's a CPU fallback.
• A specific IDE. Use whatever you ship code in.
• A specific OS. The course is Linux-first in the deploy chapter; everything else is OS-agnostic. Windows users with WSL2 are fine.
• A specific LLM provider. Patterns are vendor-neutral. Pick one and stay consistent.

Things you do need:

• Python 3.11+ installed.
• An API key with at least one LLM provider that supports tool calling.
• Git + GitHub.
• Twenty to forty hours of head-down time across whatever weeks you give it.

6. Try it

The chapter that scares you most is usually the one that has the most leverage. Hold that thought — we'll get there.

7. What's next

Chapter 1 starts at the foundation: asyncio. Every agent in this course is a concurrent Python service. If you skip the async fundamentals, every capstone will feel like it's fighting you. Fifteen minutes of theory, then you write your first event-driven agent skeleton.