« Phase 07 README · Warmup · Deep Dive · Principal Deep Dive · Core Contributor · Staff Notes

Phase 07 — Hitchhiker's Guide

The compressed practitioner tour. Read the WARMUP for the derivations; this is the stuff you say in the meeting.

30-second mental model

Multi-agent is several Phase-01 loops coordinating over a shared message bus, with roles (supervisor routes, workers act, critic verifies), typed least-context handoffs, and a bounded critique-revise loop. The one pattern that pays is the critic: verification buys back Phase 00's 0.95^n (1-(1-p)^2 turns a 0.9 step into 0.99). Everything else — routing, handoffs — is plumbing. And the senior take: most "multi-agent" systems should be one agent with good tools; adding agents multiplies cost, latency, and failure modes.

The numbers to tattoo on your arm

Framework one-liners

• AutoGen — conversational: shared message list + GroupChatManager = your bus + supervisor; termination conditions = max_turns.
• CrewAI — role/crew: agents with role/goal/backstory, a Crew, sequential or hierarchical (manager) process.
• LangGraph — graph: nodes/edges, state = blackboard, prebuilt supervisor/hierarchical, evaluator-optimizer = critique-revise, recursion_limit = max_turns.
• Google ADK — compose Sequential/Parallel/LoopAgent around LlmAgents; sub-agents + AgentTool for delegation; LoopAgent(max_iterations=...) = your bound.
• OpenAI Agents SDK — Agent(handoffs=[...]); a handoff is a validated transfer_to_<agent> tool = your make_handoff; guardrails validate at the boundary.
• All of them — bus + roles + handoff + bounded verification, with nicer ergonomics.

The five topologies

Supervisor / orchestrator-worker (the default) · Hierarchical (supervisors of supervisors) · Network / peer (direct handoffs, hard to bound) · Sequential / parallel pipeline (a workflow — hard-code it) · Blackboard (coordinate through shared state). Most real systems are supervisor-worker or a pipeline.

War stories

• The five-agent cathedral for a three-step task. Fetch → summarize → check got built as five chatting agents. It was a two-worker pipeline plus one critic; the rest was cost and latency. Collapsing it cut the bill and raised reliability (fewer seams to propagate errors).
• The context-explosion bill. Every agent was handed the full running transcript "for context." Token cost grew with agents × turns; quality dropped (lost-in-the-middle). Least-context handoffs fixed both at once.
• The critic that never approved. No max_rounds. A picky reviewer and a stubborn writer ping-ponged until someone killed the job. The bound turns "hang" into "best draft, not approved."
• The hallucinated source nobody owned. Researcher invented a citation, writer trusted it, weak critic approved it — responsibility diffusion. A real fact-check critic with the final say caught it.

Vocabulary

Supervisor / orchestrator · worker · critic / reviewer / judge · message bus / blackboard · role · handoff (typed, validated, least-context) · critique-revise / reflection / self-refine · multi-agent debate · topology (supervisor-worker, hierarchical, network, pipeline, blackboard) · ping-pong / context explosion / responsibility diffusion · max_turns / max_rounds.

Beginner mistakes

1. Reaching for multi-agent when one agent with good tools would do (the P00 reflex, again).
2. No step budget — the ping-pong loop that never terminates.
3. Handing the whole transcript to every agent (context explosion, worse quality and higher cost).
4. A supervisor with no critic — distributing unreliability instead of verifying it.
5. Not validating a handoff target (routing to an agent that doesn't exist, silently).
6. Treating debate/reflection as free reliability instead of verification with a bigger bill.
7. Ordering the message bus by wall-clock time, so runs aren't reproducible or testable.