DeLM：用共享上下文与任务队列实现去中心化多智能体系统

Overview Motivation Idea Method Results Trace analysis BibTeX

Decentralized Multi-Agent Systems with Shared Context

Parallel AgentsShared ContextTask Queue

Stanford University

Paper Code Traces Plugin

Overview

TL;DR

• Problem. Multi-agent systems run agents in parallel to tackle long-horizon tasks, yet existing designs waste much of this parallelism in bubbles: agent time spent waiting on others or redoing a peer's work.
• Idea. DeLM replaces the main agent with a shared context and a task queue. Agents claim tasks asynchronously, publish findings as soon as they are usable, and build on or correct one another's progress, with every peer's status visible to all.
• Results. On long-horizon tasks from Terminal-Bench 4.0 and DeepSWE v1.1, and on SWE-bench Verified, DeLM is both more accurate and faster than Codex, Claude Code, their native subagents, and AOrchestra: up to 17.5 points more accurate than the strongest baseline and up to 2.49× faster than the harness it builds on.

Existing multi-agent systems waste much of their parallelism in bubbles: agent time spent waiting on others or redoing a peer's work. DeLM squeezes out most of these bubbles by having agents coordinate asynchronously through a shared context and a task queue, with no main agent in the loop.

Motivation: workflow bubbles in Multi-Agent Systems

Multi-agent systems (MAS) offer a natural way to scale large language model reasoning at test time: instead of solving a complex task in a single trajectory, they decompose it into subtasks, dispatch agents in parallel, and aggregate their progress. Borrowing a term from pipeline parallelism, we call agent time that does not advance the solution a bubble: time an agent spends waiting on others, or redoing work a peer has already done. Bubbles waste compute and stretch wall-clock time, and each of the three dominant families of MAS creates them in its own way.

Independent agents

Redundant work

Their bubbles are redundant work: agents share nothing while they run, so each one rediscovers the faults, fixes, and dead ends its peers have already found.

Peer-communicating agents

Barrier waits

Their bubbles are barrier waits: each synchronous round lasts as long as its slowest agent, so agents that finish early sit idle.

Centralized orchestration

Relay waits

Their bubbles are relay waits: the main agent idles while delegated work runs, and sub-agents cannot build on each other's progress until the main agent relays it.

Replace the main agent with a shared context and a task queue

We propose Decentralized Language Models (DeLM), a coordination layer that squeezes out these bubbles by having agents coordinate asynchronously through a shared context and a task queue, with no main agent in the loop.

• No barrier or relay waits. Agents claim tasks from the task queue asynchronously, so no agent waits for a round to end or for a main agent to assign work.
• No waiting on unfinished work. Agents publish compact findings to the shared context as soon as they are usable, so peers build on intermediate progress instead of waiting for a relay.
• No redundant work. The task queue and shared context show what each agent is working on and which approaches have failed, so agents avoid redoing a peer's work.
• Updates reach everyone. Improvements and fixes are appended as new entries rather than relayed through a main agent, so every agent can pick up a peer's latest work without another round of delegation.

Decentralized Language Models (DeLM)

Given a task D, DeLM runs n agents concurrently, each with its own persistent session and workspace. Agents coordinate through two shared structures, a shared context C and a task queue T, and each agent produces its own complete solution.

1. Initialize the task queue
2. Execute subtasks in parallel
3. Summarize and publish intermediate results
4. Update the task queue as work progresses
5. Finalize each agent's solution

These operations proceed asynchronously rather than in lockstep: while one agent publishes a result, others keep working and can reuse it as soon as it appears.

Task Queue

Divides the work among agents, with no planner in charge. Any agent can add tasks or claim open ones at any time, and the first claim wins. Every task shows whether it is open, claimed, or done, and by whom, so each agent knows who is responsible for what and how much remains.

Experiments

We evaluate DeLM on four agentic coding benchmarks: Terminal-Bench 4.0, where agents share discovered environment state and failed attempts in live terminals; DeepSWE v1.1, where agents reuse each other's debugging progress on long-horizon software engineering tasks; SWE-bench Verified, where agents explore alternative root causes and fixes for real GitHub issues; and ProgramBench, where agents rebuild entire programs from scratch. We compare against Codex and Claude Code, with and without native subagents, AOrchestra, and, on SWE-bench Verified, mini-SWE-agent.

Because DeLM targets long-horizon tasks where coordination matters, we evaluate on a subset of long-running tasks from Terminal-Bench 4.0 and DeepSWE v1.1. We select tasks based on the wall-clock latency of Codex with GPT-6-Astra: for Terminal-Bench 4.0, we select 10 tasks with latency between 15 minutes and 1 hour; for DeepSWE v1.1, we select 10 tasks with latency of at least 10 minutes.

Show the 10 selected tasks from each benchmark

Selected tasks from Terminal-Bench 4.0 and DeepSWE v1.1. Baseline latency is the average execution time of the Codex baseline using GPT-6-Astra at xhigh reasoning effort.

Terminal-Bench 4.0

DeepSWE v1.1

With Claude Opus 5.5, the gains are larger: DeLM (n = 4) reaches 90.83%, 17.5 points above the strongest baseline, AOrchestra (73.33%), and runs 1.57× faster than Claude Code.

SWE-bench Verified

^a The Claude Code CLI sends cache_control blocks in the Anthropic API format, so cache reuse only works if the upstream provider honors those blocks. For Gemini-3-Flash the real cost without cache reuse is therefore around $1 per task.

With n = 4, DeLM reaches 66.08% accuracy, 10.8 points higher than the strongest baseline, AOrchestra (55.26%).

ProgramBench

Trace Analysis: How Does Decentralized Coordination Help?

Parallel subtask execution shortens the critical path

A single agent builds the CPU, graphics, and audio in sequence and finishes in 27.0 minutes. With n = 2, one agent builds the graphics and system components while its peer builds the CPU and then the audio, finishing in 20.9 minutes (1.29×). With n = 4, separate agents build the system, graphics, CPU, and audio concurrently, and the task finishes in 7.5 minutes (3.6×).

Peer-status awareness avoids duplicate exploration

DeLM exposes every agent's claims, status, and stated scope through the task queue and shared context, so an agent can notice an overlap while its search is still running and redirect. In one four-agent run, Agents 1 and 3 independently began tuning the same port widths and positions. Agent 1 then saw Agent 3's claim through the shared context:

[agent-3/FACT] [...] I will tune only w_in,w_long,w_short,y_long,y_short [...]
[agent-1/FACT] [...] applying the cavity artifact revealed agent-3 had just claimed
    the same five-parameter port tuning. [...]
[agent-1/EXEC] kill -TERM 770
[agent-1/EXEC] python binary_refine.py [...]

The agents resolve the overlap themselves, before either search finishes, without a main agent having to detect the duplication and re-plan.

Stateful shared context enables reuse and correction

Because updates and corrections are appended as new entries that reference revised files, rather than overwriting old ones, an agent can re-import a peer's updated work at any time. Across 720 agent trajectories on Terminal-Bench 4.0 and DeepSWE v1.1, agents imported shared files 5,237 times, and 80.3% of trajectories later imported a revised version of a file they had already imported. Because agents publish short summaries and attach files by reference, the shared context averages under 15K tokens at task completion.

BibTeX

citation.bib

@misc{mao2026delm,
  title         = {Decentralized Multi-Agent Systems with Shared Context},
  author        = {Yuzhen Mao and Jerry Gu and Aadi Chauhan and
                   Qizheng Zhang and Hangoo Kang and Azalia Mirhoseini},
  year          = {2026},
  eprint        = {2606.10662},
  archivePrefix = {arXiv},
  primaryClass  = {cs.MA},
  url           = {https://arxiv.org/abs/2606.10662}
}