Skimming this morning's arxiv list, one paper made me stop because it argues against something I'd quietly filed as settled: that a multi-agent system needs an orchestrator. "Decentralized Multi-Agent Systems with Shared Context" from Yuzhen Mao and Azalia Mirhoseini at Stanford rips the central controller out entirely and replaces it with a task queue and a shared, verified scratchpad. The thesis I'm taking away: the orchestrator may be the bottleneck, not the glue.
What it does#
Most multi-agent systems — including the way Claude Code spawns subagents — route everything through a central orchestrator that decomposes the task, hands out work, and stitches results back together. That controller is a serialization point and a context sink: it pays tokens to re-read and re-summarize everyone else's output. DeLM (Decentralized Language Models) removes it. Agents asynchronously claim subtasks from a shared task queue, read accumulated progress from a shared context store, do local reasoning, and write back compact updates. The shared context isn't raw transcripts — it's gist entries: completed results, failed hypotheses, constraints, and evidence, each compressed to about 100 tokens, with a coarse-to-fine design that lets an agent read the gist by default and selectively expand to raw source spans only when it needs them.
The one synchronized step is admission. Before anything enters the shared context, a verification gate checks that the gist faithfully preserves the finding and is grounded in source — bullets carry reference tags copying the first and last few words of the supporting span verbatim. Pass, and the entry becomes visible to every later agent; fail, and it's regenerated with feedback. Dependency tags on tasks plus lock-free snapshot reads keep concurrent agents from stepping on each other. It reads far more like a distributed system with an append-only verified log than like a chat between agents.
The key result#
On SWE-bench Verified with Gemini 3 Flash, DeLM hits 65.7% average pass@1 at $0.12 per task — a 9.3-point gain over the strongest baseline (AOrchestra-Parallel at 56.4%) while costing roughly half ($0.12 vs $0.25 per task). With the much stronger Claude Opus 4.6 the accuracy gap narrows to 3.3 points (78.0% vs 74.7% for centralized AOrchestra), but DeLM stays at or below the cheapest baseline's cost. On LongBench-v2 multi-doc QA it beats Claude Code and ReadAgent by 4–6 points across four model families (GPT-5.4, Sonnet 4.6, Gemini 3 Flash, DeepSeek-V4-Pro) with notably tighter variance — ±1.2 versus ±3.1 for Claude Code. The number I'm keeping: same backbone model, decentralized coordination, half the cost.
Why it matters#
Two things shift for me. First, the cost story. We usually pitch multi-agent systems as a quality play — throw more agents at the problem, get a better answer. DeLM's most quotable result isn't the accuracy bump, it's that decentralizing cut per-task cost in half on the cheaper model. The central orchestrator wasn't only a latency bottleneck; it was a token sink, repeatedly pulling every subagent's transcript into its own window to summarize and re-plan. A shared verified context flips that: each agent reads ~100-token gists by default and unfolds to raw evidence only on demand. If you're building a sub-agent architecture, that's a direct argument for a shared compact memory over a fat orchestrator context — and a reason to measure your orchestrator's token share, not just your end-to-end pass rate.
Second — and this is the part I'll actually act on — the ablation says the verification gate is the load-bearing piece. Remove admission-time verification and accuracy drops 4.9 points, the single biggest hit in the ablation, larger than dropping hierarchical summarization (−2.4). Decentralization without verification is just N agents racing to corrupt a shared scratchpad with confident-but-wrong claims. This rhymes with the reward-hacking and misalignment work I've covered: the dominant failure mode of multi-agent systems isn't "an agent can't solve its slice," it's bad state propagating to everyone downstream. DeLM's answer — gate writes, not reads, and ground every gist in copied source spans — is a pattern I'd lift straight into a centralized setup too. If you let subagents write to shared memory, verify on the way in.
The caveats#
The Opus 4.6 margin is thin (3.3pp), and the decentralization advantage shrinks on the strongest models — most of the headline win shows up on the cheaper Gemini Flash backbone. The "half the cost" claim is model-specific, not universal.
The eval is SWE-bench Verified and LongBench-v2, with the leakage and saturation concerns those now carry. No private-codebase or long-horizon multi-file test.
Vanilla DeLM actually loses to RLM on OOLONG (53.3% vs 56.0%) because natural-language shared context is unreliable for exact row-level aggregation; they need a code-execution hybrid (DeLM+RLM, 64.0%) to win there. Decentralization isn't a free lunch on structured data.
Verification adds overhead, and the whole thing inherits decomposition quality: too-coarse splits under-specify agents, too-aggressive splits spawn useless ones.
The takeaway#
What I'm filing away: the orchestrator is a design choice worth interrogating, not a default. If a multi-agent setup's controller spends most of its tokens shuttling and re-summarizing subagent output, a shared verified context plus a task queue may get the same answer for half the cost. The transferable idea isn't "go fully decentralized tomorrow" — it's "gate writes to shared state with grounded verification, and let agents read compact gists instead of each other's full transcripts." After reading this, I'm going to look at where my own sub-agent setups serialize through a coordinator and ask whether that coordinator is actually earning its tokens.