128 AI Agents With No Boss Passed 49% More Tests Than One

Microsoft Research researchers tested what happens when you give a large group of AI agents one task and appoint no leader. In the Agensh preprint, up to 1024 copies of a single language model spent six hours straight reproducing the behavior of existing programs. There was no manager, no team lead, and no handing out of subtasks; the instruction said only "everyone is equal, everyone decides for themselves."

The result was measured with the ProgramBench benchmark: the agent gets a working executable and documentation, cannot view the source or disassemble the binary, and has no internet access. It must write code with the same behavior from scratch, and hidden tests check how many cases it reproduces. Averaged over five hard tasks, a single agent passed 19.

31% of tests and a swarm of 128 passed 28.78%. That is a gain of 9.

47 percentage points, or about 49% in relative terms.

Why the lead agent was thrown out

A single agent is limited to one context window, one memory, and one thread of actions. A big task takes it a long time. The usual fix is a hierarchy: a lead agent breaks the task down and hands pieces to workers. That is how subagents work in Codex and Claude Code, Copilot fleet, and Kimi Agent Swarm. But the more workers there are, the more time the lead spends planning, coordinating, and merging other agents' work, and it becomes the bottleneck itself.

In Anthropic's research system, the lead agent launches subagents synchronously and waits for each group. That makes coordination simpler, but subagents cannot negotiate with each other, and the whole system sits idle while one of them finishes a search. Agensh removes the center entirely.

Experience with peer-to-peer swarms is still limited. In August, Anthropic's Frontier Red Team ran 10 to 80 agents for 12 hours to build a game. Early models merged changes poorly; later ones avoided conflicts by working separately. Roles and an assigned "director" in the prompts changed almost nothing. In February 2026, however, Nicholas Carlini had 16 Claude agents write a C compiler in Rust, using a shared git repository and text locks. In two weeks and about $20,000, they produced a 100,000-line compiler that builds Linux 6.9. Agensh borrows its note board from the Stanford work DeLM and adds the messenger itself.

A five-step loop and a board of short notes

All agents work at the same time and repeat one loop, which is written out in words in the prompt rather than hard-coded:

• gather context: the goal, the repository state, and colleagues' messages and findings; • claim a task: announce with a CLAIM note what you will work on, so others pick something else; • execute: write code and share useful findings along the way; • verify: check the result against the acceptance criteria and redo it if it falls short; • merge: merge the changes into the shared branch and describe what changed, why, and what confirms it.

The prompt is identical for everyone; only the agent's number differs. Three shared services run: a Gitea repository, a shared channel and direct messages in Mattermost (a direct message reaches an agent right in the middle of its turn), and a context board. The board has five note types: OBSERVED for observed behavior, FACT for a confirmed fact, FAIL for a refuted hypothesis, CLAIM for a task claim, and PATCH_SUMMARY for a description of a finished change. A note is limited to 100 characters (PATCH_SUMMARY to 300), and details go in a separate field. The prompt calls FAIL the most valuable note type: it saves everyone else from spending budget on a dead end.

Out of the 200 ProgramBench tasks, the researchers picked the five hardest: video and audio processing (FFmpeg), molecular modeling (gromacs), a document converter (pandoc), a language interpreter (PHP), and a code indexer (ctags). Every run used GPT-5.6-sol at a high reasoning level, paired with Copilot. The group of 1024 agents was spread across 16 servers with 64 each and brought up gradually: one agent every 30 seconds during the first hour, then one every three seconds.

Roles nobody assigned, and the caveats

Average share of tests passed: 19.31% for one agent, 20.68% for eight, 26.52% for 32, and 28.78% for 128. The gain is uneven: +1.37 points from one to eight agents, +5.84 from eight to 32, and +2.26 from 32 to 128. On pandoc, 128 agents exceeded 30% of tests at the 30-minute mark, 32 agents by the first hour, and eight by an hour and a half. The single agent did not reach the threshold in two hours. A thousand agents were run only on pandoc: 33.89% for one, 50.94% for 128, and 55.06% for 1024.

The swarm's behavior changed with its size under the same prompt:

• eight agents agree on a module interface and write the parts in parallel; in FFmpeg, one agent switched tasks after a conversation to avoid duplicating someone else's work; • around 30 agents start reviewing each other: in PHP, a change was approved, then another agent found a counterexample, the approval was withdrawn, the author fixed the bug, and the change was merged on the second attempt; • at 128, specialization appears: agents choose reviewers based on experience, and in pandoc two of them invented a protocol using the commit hash, which others picked up; • at a thousand, integrators emerge: the author of a change sends a request to several candidates, takes the first one to respond, and cancels the other requests.

The roles are interchangeable, so the departure of one agent does not stop the work.

There are plenty of caveats. The cost of the runs is not stated, and going from 128 to 1024 agents on pandoc yielded only +4.12 points after +17.05 over the first 128. The thousand agents ran on one task out of five. How often the agents actually collaborated is unknown: the examples come from work logs. Most importantly, the swarm was compared with a single agent, not with a swarm run by a lead agent, so the claim that "no center is better" is not proven.

The practical takeaway: this setup suits cases with an external judge. In ProgramBench that is the reference program and hidden tests; for Carlini's compiler, it is the tests and a reference GCC. In Anthropic's game experiment there was no judge, and the swarm did not succeed. The infrastructure needed is modest: Git, a chat, and a note board. The data is not enough to justify deployment, but it is enough for an experiment on a small task with ready-made tests.