In partnership with
On SWE-bench Verified, DeLM achieves 65.7% Avg@1 using Gemini 3 Flash, a 9.3-percentage-point gain over the strongest centralized baseline (AOrchestra-Parallel at 56.4%), while cutting cost per task by roughly 50% ($0.12 vs $0.25). On LongBench-v2 Multi-Doc QA, DeLM achieves the best accuracy across all four frontier model families tested, with gains up to 5.7 percentage points over the strongest baseline. The margin comes from a single architectural decision: failures, constraints, and partial discoveries are written into shared verified state rather than filtered through a main agent that may soften or discard them.
SnackOnAI Engineering | Senior AI Systems Researcher | Technical Deep Dive | July 14th, 2026
Every multi-agent system built in the past three years assumes a main agent must exist. LangGraph has a supervisor. AutoGen has an orchestrator. MetaGPT has a product manager. Claude Code Subagents route through a parent. The assumption is that someone needs to decompose the task, assign work, collect results, and merge them. The main agent is framed as the intelligence layer.
DeLM's claim is that this framing is wrong, and that the performance gap is measurable. The problem is not that centralized orchestration adds latency. The problem is that routing intermediate progress through a central controller loses information. A failed hypothesis discovered by agent 1 stays private to agent 1's trace. A constraint that should bind all future agents gets softened when the main agent rewrites it into a new prompt. A compact patch that locates a bug at an exact file and line gets buried under five paragraphs of reasoning context when the main agent extracts and re-broadcasts it.
The solution DeLM proposes: replace the main agent with a shared, verified context. Agents write directly to it. Every agent reads from it. Nothing is filtered or rewritten. If a finding is wrong, it gets rejected at admission time by an LLM verifier before it contaminates the shared state. If a finding is correct, it becomes reusable progress that any subsequent agent can build on immediately.
Scope: DeLM's three core design principles (prompt routing vs shared state, compact-unfoldable context, verified admission), the five-stage algorithm, the SWE-bench trace-level mechanisms (shared failures, binding constraints, compact patch summaries), the LongBench-v2 results and ablations, and the complementarity with Recursive Language Models (RLM). Not covered: the full OOLONG benchmark analysis, or the detailed dependency-aware queueing and KV-cache reuse optimizations in Appendix A.4.
What It Actually Does
DeLM maintains two global structures: a shared context C (a list of compact verified gists) and a task queue T (pending subtasks for parallel execution).
Five-stage pipeline (Algorithm 1 from the paper):
1. GenerateSubtasks(D, U) → T # decompose input into initial subtasks
2. RunAgents(T, C) → {r_i} # execute all ready subtasks in parallel
3. CompressAndVerify({r_i}) → {G_i} # compress each result, verify against evidence
4. C ← C ∪ {G_i} # admit verified gists to shared context
5. if T empty: GenerateMoreSubtasks or Finalize
No main agent touches step 2. Agents claim tasks from T, read C, reason locally, produce a result, compress it, and write a gist back to C. The last agent to finish step 2 in a round decides whether to generate more subtasks or finalize.
Gist hierarchy (three levels):
G_i: compact gist (~100 tokens), always in every agent's context, global navigation
S_i: reference-grounded summary, intermediate layer, retrieved when gist is insufficient
Raw source: full evidence, retrieved only when S_i confirms specific detail is needed
The paper uses an explicit OS analogy: "the gist layer functions as the small, always-resident working set visible to every agent, while S_i and the raw store serve as backing storage. Selective unfolding acts like demand paging, loading finer-grained evidence into an agent's context only when the current subtask requires it."
The Architecture, Unpacked
The verification gate is what separates DeLM from a blackboard architecture. A blackboard lets agents post raw messages. DeLM admits only gists that pass evidence-grounded verification. The shared context is curated state, not a message buffer.
The Code, Annotated
Snippet One: DeLM Core Loop and Gist Admission
# DeLM: decentralized multi-agent coordination via shared verified context
# Source: yuzhenmao/DeLM (reconstructed from Algorithm 1, arXiv:2606.10662)
# Design intent: no main agent in the coordination path.
# Progress is written to shared state and verified before becoming visible.
import asyncio
from dataclasses import dataclass, field
from typing import Optional
@dataclass
class SharedContext:
"""
The communication substrate. NOT a message buffer.
Only verified gists are admitted.
Each gist can unfold to S_i (summary) or raw evidence on demand.
"""
gists: list = field(default_factory=list)
# ← Gists are compact (~100 tokens each) and cover the full problem
# ← S_i summaries and raw evidence are stored in backing_store
# ← Not included in every agent's context window by default
backing_store: dict = field(default_factory=dict) # gist_id → {summary, raw}
@dataclass
class TaskQueue:
"""
Pending subtasks. Agents claim tasks asynchronously.
← No main agent decides which agent gets which task.
Dependency-aware: a task can declare dependencies on prior gist IDs.
"""
tasks: list = field(default_factory=list)
claimed: set = field(default_factory=set)
def claim(self, agent_id: str) -> Optional[dict]:
"""Agent pulls the next available task atomically."""
for task in self.tasks:
if task["id"] not in self.claimed and self._deps_met(task):
self.claimed.add(task["id"])
return task
return None # no ready tasks
def _deps_met(self, task) -> bool:
# ← Dependency-aware queueing: a task can wait for a prior gist to be admitted
# This is how DeLM handles sequential dependencies without a central controller
return all(dep in {g["id"] for g in context.gists}
for dep in task.get("depends_on", []))
async def run_agent(agent_id: str, task: dict, context: SharedContext) -> dict:
"""
One agent: reads C, reasons locally, returns raw result.
← Agent never writes directly to C; writing happens after verification.
← Agent sees all admitted gists in C (the compact global view).
"""
context_prompt = format_gists_for_prompt(context.gists)
# ← KV cache optimization: stable prefix from gists allows cache reuse
# ← When C grows, new gists are appended; earlier gists never change
# ← Cache the KV for the gist prefix once, share across all agents in the round
result = await llm_call(
system="You are an agent with access to the shared context below.",
user=f"{context_prompt}\n\nYour task: {task['description']}"
)
return {"agent_id": agent_id, "task_id": task["id"], "result": result}
async def compress_and_verify(raw_result: dict, source_context=None) -> Optional[dict]:
"""
The admission gate. Raw result → gist → verify → admit or reject.
← This is what separates DeLM from a blackboard: every entry is verified.
← Two paths depending on content type:
Path 1 (reasoning trajectory): compress directly, verify against trajectory
Path 2 (long source unit): hierarchical r_i → S_i → G_i with verification at each level
"""
r_i = raw_result["result"]
if is_long_source_unit(r_i):
# ← Hierarchical path: avoids lossy gist-to-raw lookup failures
# The S_i summary preserves enough structure to localize exact raw spans
S_i = await llm_call(f"Produce a reference-grounded summary of: {r_i}")
G_i = await llm_call(f"Produce a compact ~100-token gist of this summary: {S_i}")
# Two-level verification: S_i must be supported by raw; G_i must preserve S_i
s_valid = await llm_verify(claim=S_i, evidence=r_i)
g_valid = await llm_verify(claim=G_i, evidence=S_i)
if not (s_valid and g_valid):
return None # ← reject; caller will regenerate with feedback
return {"gist": G_i, "summary": S_i, "raw": r_i} # backing_store gets S_i and raw
else:
# ← Direct path for reasoning trajectories (findings, failures, constraints, patches)
G_i = await llm_call(f"Compress this reasoning result into a ~100-token gist: {r_i}")
# Verification: does G_i faithfully capture the finding/failure/constraint in r_i?
# ← This catches the case where an agent writes "USD 3B to USD 1B" but the
# evidence only says "conditional affirmance with remittitur" (no specific amounts)
valid = await llm_verify(claim=G_i, evidence=r_i)
if not valid:
return None # reject and regenerate
return {"gist": G_i, "raw": r_i}
async def delm_pipeline(task_description: str, source_context: str = None):
"""
Full DeLM pipeline. No main agent in the coordination loop.
The last agent to finish a round decides whether to continue or finalize.
"""
C = SharedContext()
T = TaskQueue()
# Step 1: one-time initialization
initial_subtasks = await generate_subtasks(task_description, source_context)
T.tasks = initial_subtasks
# ← Only this step involves centralized decision-making
# ← Everything after is decentralized
while T.tasks:
# Step 2: execute all ready tasks in parallel (no waiting for slowest if async)
ready_tasks = [t for t in T.tasks if T._deps_met(t)]
results = await asyncio.gather(*[
run_agent(f"agent_{i}", task, C)
for i, task in enumerate(ready_tasks)
])
# Step 3: compress and verify (can also run in parallel per result)
for raw in results:
gist_entry = await compress_and_verify(raw, source_context)
if gist_entry:
# Step 4: admit to shared context
C.gists.append({"id": raw["task_id"], "content": gist_entry["gist"]})
# ← Immediately visible to all agents in the next round
# ← No main agent needed to rebroadcast this
if "summary" in gist_entry:
C.backing_store[raw["task_id"]] = {
"summary": gist_entry["summary"],
"raw": gist_entry["raw"]
}
# Step 5: the most recently completed agent decides next step
# ← Not a separate main agent; just the last agent from the current round
next_tasks = await generate_more_subtasks_or_none(task_description, C)
if next_tasks:
T.tasks = next_tasks
else:
break # ← done, no more subtasks needed
return await finalize(task_description, C)
The compress_and_verify function is the architectural core. Without it, DeLM is just a blackboard. With it, the shared context becomes curated state that every agent can trust. The ablation in the paper shows removing verification drops accuracy from 60.1% to 55.2% on LongBench-v2 Multi-Doc QA.
Snippet Two: Selective Unfolding and the SWE-bench Shared Failure Pattern
# DeLM: selective unfolding and the shared failure mechanism from SWE-bench traces
# Source: Section 4.2.1, arXiv:2606.10662
# Design intent: agents read compact gists by default, unfold to evidence when needed.
# Failures are shared state, not private dead ends.
async def agent_with_unfolding(task: dict, context: SharedContext) -> dict:
"""
Agent reads compact gist layer first. Unfolds selectively when gist is insufficient.
This is the coarse-to-fine access pattern that makes DeLM efficient.
"""
# Step 1: read compact global view (all gists, ~100 tokens each)
gist_layer = "\n".join(g["content"] for g in context.gists)
# ← This is always-resident: every agent always sees the full global picture
# ← At 100 tokens per gist × N gists, this stays tractable as N grows
# Step 2: identify which gists need unfolding for this specific task
unfold_decision = await llm_call(f"""
Task: {task['description']}
Current shared context (gist layer):
{gist_layer}
Which gist IDs, if any, need to be unfolded to their detailed summary or raw evidence?
List only those needed. If none, say NONE.
""")
gist_ids_to_unfold = parse_gist_ids(unfold_decision)
detailed_context = gist_layer # start with compact layer
for gist_id in gist_ids_to_unfold:
backing = context.backing_store.get(gist_id)
if backing:
# UNFOLD: G_i → S_i (summary layer, one level deeper)
detailed_context += f"\n\n[Unfolded {gist_id} summary]:\n{backing['summary']}"
# DEEP_UNFOLD: S_i → raw (only when summary explicitly flags insufficient detail)
if "DEEP_UNFOLD" in unfold_decision:
detailed_context += f"\n\n[Raw evidence for {gist_id}]:\n{backing['raw']}"
# ← This is the PUMA EBIT example from the paper:
# Gist: "H1 2024 has narrowed EBIT outlook, details in S72.2"
# UNFOLD → S72.2 summary: "EUR 620M-670M range narrowed, exact figures in raw"
# DEEP_UNFOLD → raw: "we narrow our outlook for EBIT to EUR 620 million to EUR 670 million"
# 3-level hierarchy prevents both information loss (lossy gist) and excessive cost (full raw)
result = await llm_call(f"""
{detailed_context}
Your task: {task['description']}
Previous gist entries tell you what prior agents found, failed, or constrained.
Build on that shared progress. Don't repeat what's already been established.
""")
return {"result": result, "task_id": task["id"]}
# ─── THE SHARED FAILURE PATTERN (lambdify SWE-bench trace, paper Section 4.2.1) ──
# What happens WITHOUT DeLM (isolated trajectories):
# Agent A: tests AbstractPythonCodePrinter → fails → private to Agent A's trace
# Agent B: also tests AbstractPythonCodePrinter → fails again → $0.399 wasted
# Both agents: independently re-discover the printer path is wrong
# What happens WITH DeLM (shared verified context):
# Thread t0 produces:
gist_t0_fail = """[t0/FACT] AbstractPythonCodePrinter change did not affect lambdify output"""
# ← This negative result is now global. Costs ~20 tokens.
# Thread t1, which runs concurrently, reads the shared context BEFORE investing in printer:
gist_t1_discovery = """[t1/FACT] sympy/utilities/lambdify.py:964 _recursive_to_string
manual tuple join bypasses printer fix"""
# ← t1 skipped the detour t0 took and went directly to the real bug location
# Thread t0 continues, now knowing the bypass location:
gist_t0_defect = """[t0/FACT] sympy/utilities/lambdify.py:964 manual join for tuples
lacks trailing comma logic"""
# Thread t1 then writes the patch summary:
gist_t1_patch = """[t1/PATCH_SUMMARY] files=sympy/utilities/lambdify.py |
idea=Modify _recursive_to_string to add trailing comma for single-element tuples |
evidence=reproduce_issue.py PASSED"""
# ← This 3-line summary replaces an entire debugging trajectory (~2000 tokens of raw trace)
# ← Cost: $0.125 vs $0.399 for raw trace sharing (3.2x cheaper)
# ← The patch summary is what the next agent reads, not the full history
# ─── THE BINDING CONSTRAINT PATTERN (Django .filter() SWE-bench trace) ──────────
# WITHOUT DeLM (centralized AOrchestra):
# Sub-agent finds: single .filter() breaks M2M multi-term search
# Main agent rewrites: "could reduce joins for many use cases" → SOFTENED
# Result: globally invalid simplification gets attempted → test failure
# WITH DeLM (constraint remains in shared state, unchanged):
gist_t3_fail = """[t3/FAIL] django/contrib/admin/options.py:1041
single .filter() breaks M2M multi-term search"""
gist_t3_constraint = """[t3/FACT] Django ORM .filter(Q1, Q2) vs .filter(Q1).filter(Q2)
differs for multi-valued relations"""
gist_t3_predicate = """[t3/FACT] lookup_spawns_duplicates determines if single
.filter() is safe"""
# ← Thread t1 reads these as binding shared state (not as suggestions that can be reopened)
gist_t1_builds_on = """[t1/FACT] lookup_spawns_duplicates preserves M2M search semantics
while optimizing FKs"""
# ← t1 finds the selective optimization: OK for foreign keys, not for M2M
# ← This is ONLY possible because t3's constraint was preserved exactly in the shared context
The PATCH_SUMMARY entry is the mechanism that makes DeLM 3.2x cheaper on this task. It is not a compression trick. It is a structurally verified handoff: agent → compress → verify → admit as a 3-line evidence-backed note. Every subsequent agent reads the note, not the trajectory.
It In Action: LongBench-v2 Multi-Doc QA with DeLM
Input: Multi-document QA question from the Financial domain. The source corpus is a long corporate report containing multiple EBIT outlook entries across different reporting periods. The question asks for the most recently updated EBIT guidance.
Step 1: Initialize subtasks
Input: long document corpus (multiple sections) + question about EBIT guidance
DeLM decomposes into: 12 subtasks (one per document chunk cluster)
Initial task queue T = [chunk_1, chunk_2, ..., chunk_12]
Shared context C = [] (empty)
Step 2: Parallel execution (all 12 agents concurrently)
Agent 1 processes chunk_1: annual report EBIT section
→ produces gist G_1: "Annual report states EUR 600M-700M EBIT range for 2024"
Agent 5 processes chunk_5: H1 2024 interim report section
→ produces gist G_5: "H1 2024 interim report narrows EBIT to EUR 620M-670M [S72.2]"
(flagged: exact values require deep unfold of S72.2)
... other agents process other chunks ...
Step 3: Verification and admission
G_1: verified → admitted to C
(G_1 is grounded: annual report text does contain the cited range)
G_5: verified → admitted to C
(S_i summary is grounded in H1 2024 text; G_i preserves the qualifier "narrowed")
S72.2 summary and raw evidence stored in backing_store
G_8 (hypothetical): REJECTED
[t2 OUTPUT] "punitive damages reduced from USD 3B to USD 1B" (wrong domain, illustrative)
[t2 VERIFY] WRONG: claim not supported by cited source → regenerated without the numbers
→ admitted only after removing the unsupported specific figures
Step 4: Second round (if needed)
Queue exhausted. Last completed agent inspects C:
C contains: G_1 (annual report range) + G_5 (H1 2024 narrowed range + S72.2 pointer)
Decision: UNFOLD S72.2 needed to confirm exact values
Generates subtask: "Unfold S72.2 to retrieve exact EUR figures from H1 2024"
New agent reads S72.2 summary → requests DEEP_UNFOLD → retrieves:
"we narrow our outlook for EBIT to a range of EUR 620 million to EUR 670 million"
Produces gist G_13: "Latest 2024 EBIT guidance: EUR 620M-670M (H1 interim, later in time)"
Step 5: Finalize
All agents completed. Finalize(D, C) reads:
G_1: EUR 600M-700M (annual report)
G_5: H1 2024 interim narrows to EUR 620M-670M, see S72.2
G_13: confirmed EUR 620M-670M is the latest guidance
Final answer: EUR 620 million to EUR 670 million
DeLM accuracy: 60.1% on GPT-5.4 LongBench-v2 Multi-Doc Financial
vs ReadAgent: 57.8%, Claude Code: 65.0% on financial but lower overall avg
vs best overall baseline: 54.4% (Claude Code) → DeLM +5.7 pp overall
Ablation impact on this type of question:
Without verification: hypothetical unsupported USD figure would enter C and mislead the final agent → wrong answer
Without hierarchical summary: lossy G_5 might navigate to wrong chunk, or require unfolding too many chunks → either miss or overspend
With both: coarse navigation via G_5, precise localization via S72.2, exact values via deep unfold
Why This Design Works, and What It Trades Away
The admission-time verification is the non-negotiable component. The ablation proves it: removing verification drops accuracy 4.9 percentage points, the largest single-component contribution. The mechanism is not simply "checking that agents are correct." It is preventing unsupported claims from becoming reusable problem state. Once a claim enters the shared context, later agents may cite it, build on it, or use it to constrain their search. If it is wrong or unsupported, the error propagates. Post-hoc answer checking cannot fix this, because the error has already shaped intermediate decisions.
The hierarchical gist structure solves a genuine information-theoretic problem. If you only have compact gists, you cannot reliably locate the exact raw span you need. If you only have raw evidence, you overwhelm every agent's context window. The S_i intermediate layer is what enables the PUMA EBIT example to work: the gist says "narrowed EBIT, see S72.2," the S_i summary says "exact EUR range must come from raw," and the raw unfold provides the precise figures. Removing S_i makes this localization unreliable, explaining the 57.7% in the "No Hierarchical Summary" ablation.
The stable shared context prefix is a subtle but important systems optimization. Because gists are only appended, never modified, the beginning of the shared context is stable across rounds. This means a KV cache computed for the gist prefix during one agent's call can be reused by all other agents reading the same prefix in the same or subsequent rounds. At scale, this converts what would be quadratic context re-computation into linear amortized cost.
What DeLM trades away:
The upfront cost of hierarchical summarization and verification is real. DeLM processes the full document corpus upfront, whereas baselines like ReadAgent avoid this until retrieval is needed. The paper acknowledges this: "these baselines can cost less in long-context settings because they avoid the upfront cost of constructing and verifying a structured view of the full context." DeLM makes the opposite bet: pay more upfront for a reliable global view, then spend less on targeted retrieval. This bet pays off for accuracy, but teams with strict per-request latency budgets need to measure whether the verification round fits.
DeLM underperforms RLM on OOLONG, the structured aggregation benchmark. When questions require exact counting, filtering, and comparison over structured data, natural-language shared context is the wrong substrate. Code-mediated execution (RLM's REPL) is correct for that setting. The combined DeLM+RLM system resolves this, achieving 64.0% vs RLM alone at 56.0% and DeLM alone at 53.3%. DeLM is not a universal replacement for programmatic approaches; it is a coordination layer that can wrap them.
Technical Moats
Admission-time LLM verification is architecturally simple but operationally load-bearing. The verifier is an LLM prompt that checks whether a gist faithfully captures its supporting evidence. Implementing this correctly requires handling both path types (reasoning trajectories and long source units), defining what "faithful" means for each, and managing regeneration-with-feedback when verification fails. Teams that prototype DeLM without the verification step will achieve blackboard performance, not DeLM performance. The ablation gap is large enough that this mistake is measurable.
The gist compression budget needs empirical calibration per domain. The paper's ablation shows a threshold effect: 50 tokens gives 58.3% accuracy, 100 tokens gives 60.1%, 150 tokens gives 60.3%. The plateau at 100 tokens is specific to LongBench-v2 Multi-Doc QA. For software-engineering tasks (SWE-bench), the compression budget for PATCH_SUMMARY entries is different: the entries shown in the paper are 2-3 lines covering file, fix idea, and test evidence. A team applying DeLM to a new domain needs to find the gist budget at which accuracy plateaus for their task distribution.
The dependency-aware task queue is what prevents deadlocks. When one subtask's results need to be in C before another subtask can run meaningfully, the queue must enforce this ordering without a main agent. The paper describes dependency-aware queueing in Appendix A.4. This is the component that requires the most careful implementation engineering: how are dependencies declared, how is the "ready" check implemented atomically, and what happens when a depended-on gist fails verification and needs regeneration?
Insights
Insight One: AOrchestra-Parallel's result is the most revealing data point in the SWE-bench table. AOrchestra-Parallel improves Avg@1 over the original AOrchestra (56.4% vs 55.2%) but WORSENS Pass@2 and Pass@4 (63.2% vs 64.5% and 71.8% vs 73.2%). This means coupling parallel threads through a main agent makes them more correlated, reducing exploration diversity. When all threads share the same main agent's interpretation of prior results, they converge on similar hypotheses and make similar mistakes. DeLM's decentralized coordination, by contrast, preserves exploration diversity (Pass@4 reaches 77.4%) while still enabling progress sharing. The implication for teams building parallel agent systems is that more coordination through a central controller can hurt test-time scaling performance, not help it.
Insight Two: The most important design choice in DeLM is not the verification mechanism. It is the decision to use gists rather than raw traces as the communication unit. If agents shared full raw traces, the shared context would scale linearly with the total work done, overwhelming later agents' context windows. If agents shared no intermediate progress, DeLM would be just parallel isolated trajectories. The gist layer is the specific compression ratio that makes the shared context both informative and tractable. The paper shows the summarizer model barely matters (DeepSeek-Flash, DeepSeek-Pro, and GPT-5.4 all give ~60%): the compression level matters more than the compressor. This is a practical engineering insight: you do not need an expensive model to build DeLM's gist layer. You need the right target length for your domain.
Surprising Takeaway
The cheapest model in the paper is also the most efficient summarizer. DeLM uses DeepSeek-V4-Flash (the budget tier) as the default gist summarizer, and the ablation shows it matches DeepSeek-V4-Pro and GPT-5.4 at the same task. Meanwhile, the base models for reasoning (GPT-5.4, Claude Opus 4.6, Gemini 3 Flash, DeepSeek-V4-Pro) are the expensive frontier models. The architectural insight this reveals: the bottleneck in multi-agent coordination is not summarization quality, it is the reasoning quality of the agents and the reliability of the coordination substrate. A cheap model producing 100-token gists is sufficient for navigation and communication. The expensive models should spend their context budget on local reasoning over well-curated gists, not on summarization that a cheaper model can handle. This is a concrete cost optimization for teams building DeLM-style systems: separate the compression budget (cheap model) from the reasoning budget (expensive model), and do not compromise on verification.
TL;DR For Engineers
DeLM (yuzhenmao/DeLM, arXiv:2606.10662, Stanford University, June 2026): decentralized multi-agent framework. No main agent in the coordination loop. Two global structures: shared verified context C (compact gists, hierarchically unfoldable) and task queue T. Five stages: initialize → parallel agents → compress+verify → admit gists → generate more or finalize.
SWE-bench Verified (Gemini 3 Flash): DeLM 65.7% Avg@1, 72.9% Pass@2, 77.4% Pass@4 at $0.12/task. Strongest baseline: AOrchestra-Parallel 56.4% Avg@1, $0.25/task. Gain: +9.3pp, cost 50% lower. With Claude Opus 4.6: DeLM 78.0% Avg@1, 82.5% Pass@4.
LongBench-v2 Multi-Doc QA: DeLM best across all four frontier model families (GPT-5.4, Claude Sonnet 4.6, Gemini 3 Flash, DeepSeek-V4-Pro). Gains 3.6-5.7 pp over strongest baseline.
Ablations: removing verification: 60.1% → 55.2% (largest drop). Removing hierarchical summary: 60.1% → 57.7%. Gist length: plateau at 100 tokens. Summarizer: DeepSeek-Flash matches GPT-5.4 (use the cheap model for compression).
DeLM is complementary to RLM (programmatic execution). DeLM+RLM on OOLONG: 64.0% at $0.40, better than RLM alone (56.0%) and DeLM alone (53.3%).
The Bottleneck Was Always the Controller
DeLM's result is not that multi-agent systems work better without coordination. It is that coordination through a shared verified state is strictly better than coordination through a central controller when the number of subtasks or agents grows. The performance gap with AOrchestra-Parallel, the closest centralized baseline, is 9.3 percentage points and 50% lower cost on the same model.
The binding insight from the SWE-bench traces: when a main agent routes intermediate progress, it rewrites it. When it rewrites it, it may soften constraints, dilute findings, or bury compact discoveries under reasoning context. The admission-time verification in DeLM is the hard guarantee that what enters the shared context is what the agent actually found, not a paraphrase. That guarantee is what makes the shared context trustworthy and the downstream agents efficient.
References
DeLM GitHub Repository, yuzhenmao, Stanford University
Decentralized Multi-Agent Systems with Shared Context, arXiv:2606.10662, Mao, Mirhoseini, June 2026
DeLM Project Page, Stanford University
AOrchestra: Automating Sub-Agent Creation for Agentic Orchestration, Ruan et al., 2026 (primary centralized baseline)
Recursive Language Models (RLM), Zhang et al., 2025 (complementary system)
Explain It Like I'm New
Building an AI system to solve a complex problem with multiple agents sounds straightforward: split the problem into pieces, send each piece to a different AI, collect the answers, and combine them. One AI acts as the manager.
The problem is that the manager becomes a bottleneck. Every finding, every dead end, every useful discovery has to pass through that manager before any other AI can use it. The manager rewrites things, simplifies them, sometimes drops important details. An AI that discovered "this approach definitely won't work" needs to get that message to its peers quickly. If it has to go through the manager first, the peers may already be wasting compute on the same dead end.
DeLM is a different architecture. There is no manager in the coordination path. Instead, there is a shared notebook that every AI can read and write to directly. When one agent discovers something, it writes a short verified note to the notebook. Every other agent can immediately see it and act on it. The notebook only accepts notes that have been verified against their underlying evidence, so garbage does not accumulate.
The OS analogy from the paper is accurate: the notebook is like RAM, always visible to all agents. Detailed evidence is like disk storage, available on demand when the note says "see section 3.2 for specifics." Agents pay attention costs for the notebook, not for the full evidence store.
The practical result is that agents stop rediscovering the same failures, avoid violating constraints that have already been established, and build toward a solution faster and cheaper than any centralized approach. As multi-agent AI systems become standard infrastructure, this coordination architecture will matter as much as the underlying model quality.
See It In Action
DeLM Demo Video: Centralized vs. Decentralized Coordination Source: DeLM Project Page | https://yuzhenmao.github.io/DeLM/ The official project page hosts a video (
delm-decentralized-vs-centralized.mp4) showing the scatter-gather bottleneck of centralized MAS side-by-side with DeLM's shared-context coordination. A clear visual of how progress propagates in each system, making the architectural difference concrete without reading the paper.DeLM: Decentralized Multi-Agent Systems with Shared Context (AI Paper Explainer) Source: Emergent Mind via YouTube | https://www.youtube.com/watch?v=OIWX4VxtJUE An automated breakdown of arXiv:2606.10662 that covers the abstract and key contributions for viewers who want a quick spoken walkthrough before diving into the full paper.
VentureBeat: Stanford's DeLM Cuts Multi-Agent Task Costs 50% Without a Central Orchestrator Source: VentureBeat | https://venturebeat.com/orchestration/stanfords-delm-cuts-multi-agent-task-costs-50-without-a-central-orchestrator Practitioner-facing analysis of DeLM's implications for enterprise multi-agent builders, including direct quotes from Yuzhen Mao on the shared-failure mechanism and binding constraints. Useful context on why the 50% cost reduction matters beyond benchmark numbers.
Community Conversation
Azalia Mirhoseini (@Azaliamirh) on X https://x.com/Azaliamirh/status/2064810291574305013 Co-author announcement thread, highlighting the 65.7% SWE-bench Verified result with Gemini 3 Flash and the "asynchronous, verified, reusable progress" framing. The thread links to the paper and project page. The key framing from Mirhoseini: accuracy and cost efficiency are both improved because DeLM uses the same test-time budget more effectively, not because it uses more of it.
AlphaXiv discussion: DeLM receives 16 bookmarks in 24 hours, tagged #agents and #agentic-frameworks https://www.alphaxiv.org/abs/2606.10662 Community signal from the AI research reading community. The paper is described as "Agents Go Rogue, Share Wisdom, Save Tokens," capturing the core idea that DeLM turns the adversarial-exploration pattern (multiple agents independently rediscovering the same failures) into cooperative progress-sharing. The engagement pattern suggests this is being read by practitioners building agent infrastructure, not just ML researchers.
Ribbit Ribbit AI feed: "decentralized validated state improves programmatic aggregation" https://ribbitribbit.co Community summary noting the DeLM+RLM complementarity finding, specifically the OOLONG result where combining both methods beats either alone. This surfaces a practical design principle: DeLM and programmatic execution approaches (RLM, code-based agents) are not competing architectures but coordination layers that can be stacked. The shared context in DeLM can wrap any underlying reasoner, including code-executing agents.
DeLM (yuzhenmao/DeLM, arXiv:2606.10662, Stanford University, Yuzhen Mao and Azalia Mirhoseini, June 2026) is a decentralized multi-agent framework that replaces the central controller with two global structures: a shared verified context C (compact gists, hierarchically unfoldable to intermediate summaries S_i and raw evidence) and a task queue T. Parallel agents asynchronously claim subtasks, read C, reason locally, and write back results that pass admission-time LLM verification before entering the shared context. On SWE-bench Verified with Gemini 3 Flash, DeLM achieves 65.7% Avg@1, 72.9% Pass@2, and 77.4% Pass@4 at $0.12/task, versus the strongest centralized baseline (AOrchestra-Parallel) at 56.4% Avg@1 and $0.25/task (+9.3 pp, 50% lower cost). Three trace-level mechanisms explain this: failed hypotheses become shared reusable state rather than private dead ends; verified constraints remain binding without being softened by a main agent; and compact PATCH_SUMMARY gists carry discoveries at 3.2x lower cost than raw trace sharing. On LongBench-v2 Multi-Doc QA, DeLM achieves the highest average accuracy across four frontier model families with gains of 3.6-5.7 percentage points; ablations show admission-time verification contributes the largest gain (4.9 pp) and hierarchical summarization contributes 2.4 pp, while the gist summarizer itself can be a lightweight model (DeepSeek-V4-Flash matches GPT-5.4 at ~60%). DeLM is complementary to programmatic execution: DeLM+RLM on OOLONG achieves 64.0% versus 56.0% for RLM alone and 53.3% for DeLM alone.
Sponsored Ad
If you enjoy practical AI insights, check out SnackOnAI and support the newsletter by subscribing, sharing, and exploring our sponsored ad — it helps us keep building and delivering value 🚀
Try the AI that knows your customers. No commitment.
Most platform evaluations start with a demo request and end three weeks later in a conference room. This one takes 15 minutes and puts you directly inside Gladly's interface — navigating it on your own terms.
See how AI surfaces real-time customer context before a conversation starts. Watch how a single conversation thread pulls in purchase history, channel history, and account details without a handoff.
No installation. No commitment. Start the interactive demo and see the platform for yourself.