Four shapes cover almost every agent graph you'll build.
Ten lectures and two project labs on the shape problem: why most of the edges in a multi-agent workflow are imaginary, how to write node contracts a graph can route on, when to fan work out instead of chaining it, and where durable state and topology-as-cost-model keep a graph from becoming an expensive mess.
You finish holding something.
You leave able to look at any multi-step agent task and answer three questions without guessing: which steps genuinely depend on each other, where the graph should fan out instead of chain, and whether the task earns a graph at all instead of staying a single loop.
The artifact
A working graph design for one real task of yours — node contracts, a route table, a join rule, a durable state schema, and a written cost breakdown — plus the judgment to know when not to build one.
The loop you learn
Map → Contract → Route → Verify
Every lesson has the same shape.
You know what you are buying before you buy it.
01Failure first
Every lecture opens on a concrete coordination failure — a stalled chain, a self-approving reviewer, a run that dies with no memory of where it was — not on an agenda.
02The mechanism
Why the failure happens structurally, and the smallest change to the graph's shape that removes it.
03Self-check
Questions inline, answers hidden until you commit to one.
04Deliverable
A named artefact — a dependency map, a contract, a route table, a state schema — you add to your own graph design before moving on.
Why it is built this way.
Three decisions that shaped every lesson.
An edge is a claim, not decoration
Every arrow in a graph diagram should mean one thing: the next node reads what the last node produced. An arrow that doesn't earn that claim is a chain you built out of habit, not dependency.
Contracts before wiring
A node without a named job, a declared input, a structured output, and a named failure state isn't ready to connect to anything. Fix the node before you fix the graph.
Shape is a cost model, not an aesthetic
Fan-out is not free parallelism — it's a spend decision. The topology you draw determines what the run costs before a single token is generated.
6 modules, 12 entries.
The whole path is public. Nothing is hidden until you pay — only the bodies are gated.
MOD 01Prologue
The hook: most of the arrows in your workflow diagram are imaginary, and that's costing you wall-clock time, not correctness.
- 01The Shape ProblemRead · 14m · concise path · 3 quiz · free · updated 2026-09-16
You end with: A dependency map of one real multi-step agent task you run today, with every arrow labeled real or assumed.
MOD 02I. Map the Real Work
Separate genuine read-dependencies from arrows you drew out of habit, then give every remaining node a contract the graph can route on.
- 02Auditing a Real Task's EdgesRead · 11m · concise path · 3 quiz · updated 2026-09-15
You end with: Your task's dependency map redrawn with every fake edge removed — only true read-dependencies remain.
- 03A Node You Can't Describe Is a Node You Can't RouteRead · 12m · concise path · 3 quiz · updated 2026-09-15
You end with: A written contract — job, input, structured output, named failure state — for every node in that map.
MOD 03II. Shape the Coordination
Classify your graph into the four shapes that cover almost everything, then decide where a fan actually needs a join.
- 04Four Shapes Cover Almost EverythingRead · 12m · concise path · 3 quiz · updated 2026-09-15
You end with: Your graph re-classified into chain, fan, router, and cycle segments — one shape per segment, named.
- 05A Join Is a Decision, Not a FormalityRead · 11m · concise path · 3 quiz · updated 2026-09-15
You end with: A join point defined for your fan-out, with a written reason it's needed and a partial-failure rule.
MOD 04III. Control and Verification
Split what the model judges from what the graph decides, then put a verifier on the edge instead of inside the generator.
- 06Let the Model Judge, Let the Graph DecideRead · 11m · concise path · 3 quiz · updated 2026-09-15
You end with: A route table that separates your classifier (model, probabilistic) from your router (table, deterministic).
- 07The Most Valuable Node Produces NothingRead · 9m · concise path · 3 quiz · updated 2026-09-15
You end with: A standalone verifier node, running in its own context, gating one generator's output in your graph.
MOD 05IV. State and Cost
Give the graph durable state that survives a crash, then price the shape you drew before you run it.
- 08State Is the Part the Diagram HidesRead · 10m · concise path · 3 quiz · updated 2026-09-15
You end with: A durable state schema for your graph: current node, completed nodes, artifact references, budget, retries.
- 09Your Shape Is Your Cost ModelRead · 10m · concise path · 3 quiz · updated 2026-09-15
You end with: A cost table for your graph: which nodes run on a cheap model, which earn a strong one, and the written reason for each.
MOD 06V. Judgment and Capstone
Decide when a graph is the wrong tool, place the five engineering layers in order, then build one for real.
- 10When a Graph Is the Wrong ToolRead · 13m · concise path · 3 quiz · updated 2026-09-15
You end with: A one-page decision note: does a specific task of yours earn a graph, or does it stay a loop, with the five layers placed in order underneath it.
- 11Build a Fan/Join GraphProject · 10m · updated 2026-09-15
You end with: A working fan/join graph — node contracts, route table, join rule — applied to a real task, plus a measured before/after against the chained version.
- 12Add a Verifier and Durable StateProject · 10m · updated 2026-09-15
You end with: That same graph extended with a standalone verifier node and a durable state file that survives a mid-run crash and resumes correctly.
Start with the free lesson.
Engineers who already run single-loop coding or research agents and are hitting tasks a single loop can't hold.
- One-time price, lifetime updates
- Every course included — this one and the next
- 30-day money-back guarantee
- No card required to start