Subagents Multiply Hallucinations: Isolate Them

A five-agent fleet agrees on a fiction

Parallelize a feature across five subagents: auth, billing, UI, tests, docs. Each reports success. Then integration reveals the foundation was fictional — the lead agent's wrong assumption about the user model ("plan lives on the session") propagated into all five outputs, each built perfectly atop the same lie.

Five agents hadn't divided the work. They'd multiplied the error by five, with consensus as camouflage: "but they all agree!" Yes — they all read the same wrong brief. Agreement among the misled is not evidence. It's an echo chamber with commit access.

Subagents hallucinations don't add. They amplify — one wrong premise, N confident implementations, integration day ruins.

Single agent vs fanned-out fiction

Three things fan-out teaches, painfully:

1. Shared briefs share blindness. All five agents read the same ambiguous spec identically — same gap, same guess, five implementations of the same wrong thing. Fan-out without per-agent verification multiplies the brief's defects by headcount. The brief is the single point of failure; agents are the amplifiers.
2. Integration is where fictions meet. Each output passed its own checks (tests asserting shared assumptions). Reality arrived only at merge — five "greens" colliding into one red. unverified-per-link chains compound exactly like this: trust transitive, truth absent. Every handoff needs exhibits or the chain is folklore.
3. Consensus feels like proof. Five confident reports create social proof no single agent could — approvals come faster with less scrutiny, the worst possible response to multiplied risk. Agreement scales confidence superlinearly while adding zero evidence. Count exhibits, never heads.

The prove-it post demands per-link verification. This one explains why links rot fastest in parallel.

Subagents hallucinations containment

Isolate tasks, verify handoffs, integrate sequentially — parallel speed with serial truth.

Step 1 — Isolate: one agent, named files, no shared writes.

TASK: <one behavior> | FILES: <named, ≤3> | READS: <frozen brief v1.2>
WRITES: own files only (shared files = main agent merges, never subagents)
PROOF: gate + curls pasted before handoff (unproven work doesn't travel)

Frozen brief versions (no mid-flight edits propagating differently per agent), disjoint write sets (merge conflicts structurally impossible), proof-per-handoff (fiction stops at its source). Isolation converts five interacting unknowns into five checkable units. Parallelize execution, never truth.

Step 2 — Verify every handoff before building on it.

# main agent, per subagent delivery (minutes each, non-skippable):
npm run lint && curl <their endpoint> && grep <their guard> && read <their diff>
# fail ANY → reject to that subagent with specifics (never fix forward for them)

Downstream agents build only on verified upstream output — unverified foundations are how fictions compound. Reject-with-specifics (not fix-forward) keeps responsibility with the author who holds context. Handoff verification is the tax parallel pays for its speed; skip it and pay integration-quarter rates instead.

Step 3 — Integrate sequentially, never big-bang.

# merge order: schema → provider → route → UI → tests (dependency order, verified each)
# after EACH merge: gate + health + the new surface curled (green to proceed)
# big-bang merges are banned: five fictions arriving together is undebuggable

Sequential integration localizes blame (break appeared at step 3 → step 3's fiction) where big-bang anonymizes it (something among five broke, good luck). Green-between-merges means the last green state is always one step back — retreats are single-step, not archaeology. Order is the debugger fan-out lacks.

Exactly the design — fleets that verify, never echo.

Fanned fiction vs isolated fleet

BoringPush fleets verify per link before building onward.

Naming the cost: isolation plus per-handoff verification costs ~30 minutes of orchestration per fan-out — the "overhead" that feels slower than fire-and-forget. Priced against multi-day fiction archaeology: orchestration is 10x cheaper than integration incidents, every single time. Parallelize for speed, verify for truth, never confuse the two directions.

FAQ

Are subagents hallucinations worse with more agents or smarter models?

More agents, linearly (each a new amplifier for brief defects); smarter models, subtly (better-written fictions, harder to spot). Five average agents with verification beat five brilliant agents without it — process dominates capability in parallel exactly as in serial. Scale headcount with verification budget, never ahead of it.

Should subagents share context windows or stay blind?

Share the frozen brief, nothing else: shared full context lets one agent's fiction infect others mid-flight (contamination), while blindness plus frozen brief keeps defects localizable. Brief frozen at fan-out time, updates versioned (v1.3 → all agents restart affected slices). Shared truth versioned, working memory private. Quarantine by default.

How small should isolated tasks be?

One behavior, ≤3 named files, independently verifiable (own gate + curls + proof). Smaller tasks verify faster and localize blame tighter; the overhead per task (~5 min orchestration) stays flat while risk falls with size. When in doubt, split once more — orchestration scales linearly, fiction scales exponentially. Small slices, big safety.

Can the main agent also build, or only orchestrate?

Orchestrate plus the trickiest slice (schema usually — the foundation everything reads). Main-agent building keeps architecture judgment central while subagents execute bounded slices. Overloaded mains become bottlenecks; pure-orchestrator mains waste the strongest reasoner. Lead plus hardest slice: authority with skin in the game.

What kills subagent fleets most often in practice?

Shared mutable state (two agents writing one file — merge fiction), drifting briefs (mid-flight edits reaching agents unevenly), and unverified handoffs (building on unproven output). All three are isolation failures, all three die to the contract above. Fleets fail socially (coordination) more than technically (capability) — govern the interfaces, trust the engines.

When are subagents simply the wrong tool?

Tightly-coupled work (single-file refactors, intertwined logic), exploratory spikes (unknown shape, needs one mind), and tiny tasks (orchestration overhead exceeds build time). Fan-out suits parallelizable, well-specified, multi-surface features — the minority of real work, honestly. Default single-agent sliced; fan out on evidence of parallelizability, never enthusiasm.

Keep reading

• Don't Ship It. Prove It First. — per-link proof, the companion law
• 30 Calls for a 3-Call Task: Stop Agent Token Loops — the serial version of this waste
• Mobile AI Guardrails: Couch Fixes That Can't Break Prod — small sessions that can't fan out dangerously