Microsoft Research has released Agensh, an open-source system that coordinates up to 1,024 coding agents without a central leader.
The core change
Most multi-agent frameworks rely on a single orchestrator to plan work and merge results. Agensh removes that bottleneck. Every worker node picks its own sub-task, shares findings, and merges code directly into a shared Git repository.
The team tested this setup on ProgramBench, scaling the system from a single agent to 1,024 agents.
Technical specifications
The system runs on Linux using Docker Compose. The default single-node setup handles eight workers. The 1,024-agent test required 16 nodes, with 64 agents running on each. Each worker has a memory ceiling of 64 GiB.
Input limits are set at 272,000 tokens per worker, with an output limit of 128,000 tokens.
Performance results on ProgramBench
The team evaluated the harness on the five hardest tasks in the ProgramBench dataset: FFmpeg, gromacs, pandoc, PHP-src, and ctags. Agents rebuild these programs from observed behavior within a six-hour window.
Using the GPT-5.6-sol model, the mean final test-pass rate for the five tasks improved as follows:
- 1 agent: 19.31%
- 8 agents: 20.68%
- 32 agents: 26.52%
- 128 agents: 28.78%
This represents a 9.47 percentage point gain, or roughly a 49% relative improvement. On the pandoc task alone, scores rose from 33.89% with one agent to 55.06% with 1,024 agents.
Speed also increased. With 128 agents, the system passed 30% of the pandoc benchmarks in 30 minutes. Smaller teams required longer: 32 agents took 60 minutes, while 8 agents needed 90 minutes.
The Microsoft README notes a newer model result not in the original paper. Using GPT-6.1-sol, the pandoc pass rate reached 79.59% with just 32 agents, up from 56.19% with a single agent.
Emergent behaviours
The research team tracked how worker behaviour changed as the team size grew. None of these roles were hard-coded into the system.
- 8 agents: Peers agreed on interfaces and resolved overlapping claims themselves.
- 32 agents: Peers reviewed shared work; one approval was withdrawn after a counterexample was found.
- 128 agents: Workers reused trusted reviewers and standardised an integration protocol.
- 1,024 agents: Several workers acted as integrators, and peers recovered failed work.
System architecture
Each worker runs the same five-step loop concurrently and asynchronously:
- Gather context: Read the goal, peer progress, messages and findings.
- Claim a sub-task: Post a CLAIM, then settle overlaps by direct message.
- Take action: Work locally with tools and post useful findings early.
- Verify results: Check the work against the sub-task’s acceptance criteria.
- Merge progress: Merge into the shared repo, post an update, then repeat.
Three services connect the workers. Gitea hosts the shared workspace, managing branches, pull requests and merge conflicts. Mattermost carries a team channel plus direct messages for urgent collisions. A shared context board, adapted from DeLM, stores typed notes: OBSERVED, FACT, FAIL, CLAIM and PATCH_SUMMARY.
The loop exists in the prompt, not in runtime code. Every worker receives the same prompt except its ID. Agensh sits on top of a single-agent harness. The experiments used GitHub Copilot CLI, though the research paper states thin adapters can connect other harnesses, such as Claude Code.
Comparison with other frameworks
Agensh differs from other tools by removing the central orchestrator. Claude Code agent teams use a fixed lead session to coordinate teammates. Kimi Agent Swarm uses an orchestrator to decompose tasks. Copilot CLI assigns parts to subagents.
While other systems recommend small teams of three to five agents or support up to 100 sub-agents, Agensh demonstrated stability at 1,024 agents. It is open source under the MIT license, whereas Claude Code teams are experimental and off by default in the commercial product.
Getting started
The release includes a single-node Docker Compose team and a single-agent baseline. Both use native Copilot ACP sessions. You need Linux with Docker Engine, Compose v2, systemd, cgroup v2 and Python 3.11+. Defaults are set to 8 workers, 6 hours per task and gpt-5.6-sol at high effort.
Full steps sit in the reproduction guide on the GitHub repository.
What it means
For engineers building large-scale automation, this removes the single point of failure inherent in centralised planning. If the lead agent stalls or hallucinates, the swarm continues working. The practical implication is that complex tasks requiring hundreds of concurrent code paths can now be executed without a single bottleneck agent managing the workflow.
