Four topologies, one decision.

One loop, one context, one trace. Every capability you want arrives as a tool (Week 5), not as a colleague. Nothing is handed off, so nothing can be dropped in a hand-off. When people say "we built an agent", this is almost always what they built — and it is what your Capstone Milestone I should be.

It stops working for a specific, nameable reason: the context window fills with instructions and results for jobs that have nothing to do with each other, or the tool list gets long enough that the model picks wrong. Those are the symptoms worth measuring before you reach for a second agent.

You are allowed to leave Pattern 0 when you can complete this sentence with evidence: "The task splits into subtasks that can run in parallel, and each subtask's output can be verified on its own."

If you cannot, the patterns below will make your system slower, costlier, and harder to debug while looking more sophisticated. That is the trap this week exists to prevent. Page 02 makes the case against in detail.

A lead agent receives the user's query, thinks about how to approach it, and spawns subagents that search in parallel. Each subagent works in its own context window with its own tools, then returns findings to the lead, which decides whether to spawn more, and finally synthesizes an answer. The subagents do not talk to each other — a deliberate restriction, exactly the n−1 channels point from the week's home page.

Why the pattern fits: open-ended research is breadth-first. "What are the board members of the top five companies in X?" is genuinely four or five independent lookups, each verifiable on its own. That is the canonical shape.

Anthropic Engineering — How we built our multi-agent research system ↗ (this week's reading)

Anthropic reports that the multi-agent system used roughly 15× more tokens than a chat interaction, and that it outperformed a single-agent baseline on their internal research evaluation by about 90%. Both figures are as reported in their engineering post and are approximate — do not quote them as general laws of multi-agent systems. They describe one system on one internal eval.

The right lesson is not "multi-agent is 15× worse" or "multi-agent is 90% better". It is: the value has to be large enough to survive the multiplier. Anthropic's own framing is that this only makes sense for tasks valuable enough to justify the spend. Most CRUD-shaped agent work is not.

Both agents read and write the same object — a plan, a draft, a scratchpad, a LangGraph state dict. Nothing is "sent"; changes are simply visible.

Buys: no information is lost in translation; agents cannot hold contradictory pictures of a shared field.
Costs: the classic concurrency problems arrive with it — two agents editing the same field, last-write-wins, and an ever-growing shared blob that every agent must now read (which is the context problem you were trying to escape).

Agent A finishes and passes a payload to agent B. B's context contains only what A chose to send.

Buys: clean, small contexts and clear boundaries — each agent's window holds one job.
Costs: whatever A did not put in the payload is gone. B re-derives it, guesses it, or silently works from a different assumption. This is context fragmentation, and it is the single most common cause of confidently contradictory multi-agent output.

The user says "keep it under 400 words and cite every claim." The supervisor passes the topic to a writer but not the word limit. The writer produces 900 excellent words. A formatter agent trims to 400 by deleting the citations — the only instruction it was given was the length.

No agent malfunctioned. Every agent did its job correctly on the input it received. The system still violated the user's requirement, because the requirement was never in the payload. That is a specification and design failure in the MAST taxonomy (Cemri et al., 2025) — and you will meet it again on page 02.

From Chaos to Choreography (AI Engineer, 26m28s)

Sandipan Bhaumik surveys the orchestration patterns that hold up in real deployments and the ones that quietly fall over — the same four shapes you just clicked through, argued from production experience.

Fully local multi-agent systems with LangGraph (LangChain, 13m14s)

The vendor-official walkthrough, in the stack you already know from Week 4. Watch specifically for where the graph decides routing — in LangGraph, "which agent goes next" is just another conditional edge.