Agensh: Scaling Organizational Intelligence to 1,024 Agents
Zhihao Zhan, Ting Song, Li Dong, Shaohan Huang, Jianxun Lian, Yan Xia, Furu Wei
cs.CL, cs.MA
2026-09-23
Microsoft Agensh skips the orchestrator so workers self-assign. On the five hardest ProgramBench tasks, 128 agents lift mean pass from 19.31% to 28.78%; 1,024 take pandoc to 55%.
Most multi-agent harnesses still look like orchestrator plus workers. A lead agent decomposes the job, assigns pieces, and stitches results back. Claude Code agent teams, Codex sub-agents, Copilot fleet, and Kimi Agent Swarm all sit in that family. The orchestrator has to plan, manage, and integrate. Past a point, that one context becomes the bottleneck. Hard software tasks also come with a clock. A single agent has one action stream and one window; six hours is often not enough to rebuild a large repository.
Microsoft Research removes the orchestrator. Every worker runs the same loop and the same prompt, differing only by worker ID. They claim work, talk, and merge through a shared workspace, a message bus, and a shared board. The bet is that headcount itself can be a scaling axis: higher final scores, and less time to reach a given score.
Each worker repeats five steps asynchronously:
The infrastructure is three services. The shared workspace is Git on Gitea: private branches, merge to main, workers resolve conflicts. Messaging is Mattermost: a task channel for announcements, direct messages injected into the current turn to break ownership collisions. Shared context follows DeLM. Typed entries are OBSERVED, FACT, FAIL, CLAIM, and PATCHSUMMARY, with a grep tool over the full history beyond recent memory. FAIL is treated as the highest-value note, because it stops peers from spending budget on a dead hypothesis.
Agensh is an organization layer around a single-agent harness. These experiments use Copilot underneath. The cooperation loop lives in the prompt, not in hardcoded runtime logic, so Claude Code or another adapter can be swapped in. The runtime is event-driven: Gitea and Mattermost activity enter a durable queue, and a worker idle for 10 minutes gets a nudge. The 1,024-worker run is split across 16 nodes, 64 agents each. To cut scope contention, startup is staggered: one agent every 30 seconds in the first hour, then every 3 seconds. Two stop-the-new-features reminders go out at T-45 min and T-5 min.
Evaluation uses ProgramBench's five hardest from-scratch rebuilds: FFmpeg, gromacs, pandoc, PHP-src, and ctags. No internet, a 6-hour budget, the reference binary can be run but not decompiled. The model is GPT-5.6-sol with high reasoning. Repositories range from pandoc at 2,767 files and 104k lines to PHP-src at 26,266 files and 2.81M lines.
| Scale | Mean final pass, five tasks | pandoc final pass |
| 1 agent | 19.31% | 33.89% |
| 8 agents | 20.68% | not reported alone |
| 32 agents | 26.52% | not reported alone |
| 128 agents | 28.78% | 50.94% |
| 1,024 agents | five-task mean not run | 55.06% |
One to 128 agents is about a 49% relative gain, or 9.47 points absolute. On pandoc, 128 agents cross 30% pass at 30 minutes, 32 agents at 60, 8 agents at 90. The single agent stays below that line for the first two hours.
Trajectories show organization changing with scale. At 8, workers agree on an interface and split implementation; a colliding CLAIM gets a scope change. At 32, several peers review a PR and withdraw approval when someone finds a counterexample. At 128, reviewers are chosen by prior experience. On pandoc they even negotiate a protocol: author tests, sends a commit hash, a peer validates and merges; after failures they hand the whole update-test-merge cycle to a peer. At 1,024, several workers act as integrators. An author pings several candidates, keeps the first valid reply, cancels the rest. Peers in the same technical area can also take over after a failed attempt.
This is a path to "add more agents" that does not require a stronger orchestrator. On timed engineering work, extra heads mostly buy time-to-score, plus a slower climb in the final number. The code is public. Because the loop is prompt-level, it can in principle wrap existing coding agents.
Do not read 55% as "1,024 agents rewrote pandoc." This is an offline from-scratch rebuild against hidden tests. Nearly half the tests still fail. From 128 to 1,024 agents the extra gain is 4.12 points. Returns are already flattening.
The paper has no standalone Limitations section. The 1,024-agent run is pandoc only; there is no five-task mean at that scale. There is also no matched orchestrator-worker baseline at the same headcount, so "you have to drop the orchestrator to scale" is an inference, not a measured result.
Staggered launch, two global wind-down reminders, and idle nudges are all coordination injected from outside. The single-agent baseline got an extra stop hook telling it not to sit inside the original plan and to fill the 6 hours, because a lone agent rarely lasts that long. Headcount is therefore tangled with extra runtime scaffolding.
Cost is unreported. 1,024 copies of GPT-5.6-sol high, 272k input / 128k output caps, for 6 hours, will not be cheap. Emergent roles are qualitative readings of traces, with no counts of how often an integrator appears. A shared Git repo is a natural fit for ProgramBench, where tests run and diffs merge. Whether the same infrastructure holds on work that cannot merge by diff is untested.