Deep-Dives / Multi-Agent Systems

Multi-Agent Systems

When multiple agents pay off, when one beats many, and the topologies, failure modes and debate patterns in between.

  1. When (and When Not) to Go Multi-Agent
    Price the coordination tax before you split: the three honest reasons to add an agent, and when one agent with tools wins.
  2. Multi-Agent Topologies
    Every edge in a multi-agent graph is a place where context gets cut: Google’s controlled study found the same wirings gaining up to 80.8% on parallel financial reasoning and losing 39–70% on sequential planning — so fan out reads, keep coupled writes in one agent, and put a checker, not a merger, at the hub.
  3. Supervisor / Worker Orchestration
    The pattern that actually ships: plan, dispatch isolated workers, aggregate — and why the supervisor is the bottleneck.
  4. Debate, Voting & Ensembles
    Most of the gain is ensembling, not debate; without engineered diversity, debate collapses to the initial majority.
  5. Shared Memory & the Blackboard
    A blackboard replaces N² messages with one shared store — and inherits write contention, stale reads, and lost updates.
  6. Multi-Agent Failure Modes
    Error propagation, groupthink, deadlock/livelock, cost explosion — the system-level bugs single-agent tooling cannot see.
  7. Sub-Agent Patterns Compared
    LangGraph supervisor / hierarchical / collaborative vs OpenAI Agents SDK handoffs-vs-agents-as-tools vs deepagents — when each shape works.
  8. Credit Assignment: Which Agent Do You Change?
    A run-level score contains no gradient, so per-agent judges, ablation and counterfactual replay answer three different questions — local quality, marginal contribution, and specific causation — and reporting the cheapest as though it were the most specific is how a team spends a quarter tuning the worker that did exactly what it was told.
  9. What a Sub-Agent Actually Inherits
    Every framework gives you a switch for how much conversation a sub-agent inherits and none for how much authority, so the setting you tune costs tokens while the one you cannot see decides how bad a compromised run gets. Tools bind to the process, not the conversation: an isolated sub-agent is a fresh context window with identical reach, and fan-out buys concurrency at constant authority. Worse, isolation launders provenance — a brief written from a hostile page arrives in the child's instruction position looking trusted. Five inheritance decisions, one declaration per role.
  10. Isolated Runs That Find Each Other
    Isolation is enforced at the process boundary and specified at the information boundary, so any object two runs can write and read turns a fleet into one system with no supervisor and no aggregate budget. Convergent discovery makes the first occurrence and the hundredth minutes apart at fleet scale; five things then break, four of them silently, including the statistical independence your confidence interval assumed. Detect it in the join, namespace every writable object unguessably, and give the cohort an owner that can stop it.
  11. Terminating a Multi-Agent Run
    LangGraph stops at 25 steps by default — about twelve tool calls — and that cap measures effort rather than completion, so it fires identically on a run that was nearly done and one that was looping. MAST names both termination failures and they are opposites, which makes the cap a dial between them rather than a safety net. Three distinguishable exits, a shared budget ledger instead of per-agent caps that multiply under fan-out, and a completion decision taken by anything other than the agent claiming to be finished.
  12. The Fan-Out Tax
    Fan-out is sold as tokens traded for wall-clock and both sides are mismeasured: on an 8,000-token prefix, three branches of six steps cost 1.8x the prefix a single 18-step loop paid and six branches 2.9x, because each branch opens with a cache miss at the 1.25x write multiplier instead of reading at 0.1x — while the latency win is capped by the slowest branch, so 1 to 3 branches buys a factor of two and 3 to 6 buys almost nothing. Cap the fan by the merge budget you can reason over, not the worker count you can afford, and instrument cache-hit rate per branch, merge share of input, and seconds saved per extra dollar.
  13. Parallel Writes and the Silent Merge
    A worktree per agent eliminates lost updates and stale reads and leaves write skew untouched, because git's detector is textual: a worker that renames a helper and a worker that adds a caller for the old name touch no common line, pass their own suites, and merge clean into an ImportError. The defect is a property of the pair, so no per-worker review finds it. Partition by interface rather than by ticket, grant signature-changing privileges to one worker per round, run merges through a single serialised lane with the full suite after each one, and outside a repository fall back to conditional writes, intent-keyed effects and per-worker namespaces.