Microsoft Research's Agensh system scales multi-agent software engineering to 1,024 concurrent workers without a central orchestrator, raising test-pass rates on complex code-reproduction tasks by coordinating through shared workspace, asynchronous messaging, and a distributed task-claiming loop. On the five hardest ProgramBench benchmarks, scaling from 1 to 128 agents raises the mean final test-pass rate from 19.31% to 28.78%, a 49% relative improvement. On pandoc alone, scaling to 1,024 agents raises the final test-pass rate from 33.89% to 55.06%, a 21.17 percentage-point gain.
The system couples a five-step cooperation loop with three coordination mechanisms. Each worker gathers context from shared state, claims a sub-task by announcing it to peers, executes work locally, verifies results against acceptance criteria, and merges verified contributions back into a shared Git workspace. Peers communicate through a message interface carrying team announcements and direct messages, and publish findings to a shared context board—a typed append-only log of observations, confirmed facts, failed approaches, active claims, and patch summaries. Workers proceed asynchronously; new entries on the shared context are forwarded to all peers at the next infrastructure tool call, making discoveries visible across the organization without waiting for synchronization.
The infrastructure uses Gitea for the shared workspace, Mattermost for messaging, and an append-only database for shared context. Workers are implemented as prompts layered above a single-agent harness—in the experiments, Copilot with GPT-5.6-sol (high)—so the system can connect to different underlying harnesses through lightweight adapters. The paper does not report wall-clock time or token cost at scale, only test-pass rates and latency to reach intermediate performance thresholds.
The paper's experiments run under a fixed 6-hour budget on ProgramBench, which requires agents to reconstruct reference software from scratch without internet access. The five tasks span multimedia processing (FFmpeg, 1.5M lines), molecular simulation (gromacs, 815K lines), document conversion (pandoc, 104K lines), language interpretation (PHP-src, 2.8M lines), and code indexing (ctags, 246K lines). Figure 6 shows that larger organizations reach intermediate test-pass rates earlier: on pandoc, 128 agents exceed 30% test-pass rate at the 30-minute checkpoint, while 8 agents first exceed that threshold at 90 minutes.
Beyond performance gains, recorded worker trajectories reveal emergent self-organized cooperation. At 8 agents, workers coordinate implementation by announcing module interfaces and independently implementing components that conform to them. At 32 agents, multiple workers jointly review contributions and manage integration across peers. At 128 agents, workers specialize by selecting reviewers based on prior experience and establish standardized workflows—in pandoc, two workers created a protocol where the author updates and tests a branch, then sends its commit hash for peer validation and merge. At 1,024 agents, multiple workers take on the same specialized roles; in pandoc, multiple integrators allow a worker to contact several candidates, select the first responder, and cancel other requests, strengthening robustness by avoiding dependence on any individual worker.
The system's core limitation is the absence of operational cost and latency data. The paper measures only test-pass rates and time-to-threshold, not token consumption per agent, inference latency per loop iteration, or total compute cost for the 1,024-agent run. For architects evaluating whether decentralized coordination scales cost-effectively, the paper provides no basis for comparison against orchestrator-based systems or against single-agent baselines on the same hardware budget.
If you are building a multi-agent system for long-horizon tasks under hard time constraints, decentralized task claiming and shared workspace coordination can improve quality and speed without a bottleneck orchestrator—but measure token cost and latency in your own stack before committing to scale.