Microsoft open-sources Agensh, a way to run 1,024 coding agents with no boss agent

A team with no manager

Microsoft Research has released Agensh as open source, as marktechpost.com reported. It is a harness, meaning the scaffolding that launches AI agents, gives them tools and keeps them working together. Its distinguishing choice is that nobody is in charge.

Many agent systems use an orchestrator-worker design. One lead agent makes the plan, hands out pieces and merges the results. The Agensh paper names several well-known products that work this way, including Claude Code's agent teams, Codex sub-agents, Copilot's fleet feature and Kimi Agent Swarm. Microsoft's team calls the limit this creates the orchestrator ceiling: the more workers you add, the more the single lead has to juggle.

In Agensh, each worker decides what to do next, announces it, does the work and merges its own code into a common Git repository. The team tested the approach from a single agent all the way up to 1,024.

How the workers stay out of each other's way

Every worker repeats the same five-step cycle, all at once and without waiting on the others. It reads the goal and what its peers have posted, claims a sub-task, works on it with its tools, checks the result against that sub-task's acceptance criteria, then merges and posts an update.

Three ordinary services tie this together:

• Gitea hosts the shared code, with branches, pull requests and merge conflicts.
• Mattermost is a chat tool. It has a team channel, plus direct messages for urgent collisions, such as two workers claiming the same job.
• A shared context board, adapted from a project called DeLM, holds short typed notes labeled OBSERVED, FACT, FAIL, CLAIM and PATCH_SUMMARY.

The cooperation rules are written into the agents' instructions rather than coded into a program. All workers get the same prompt apart from their ID. Agensh runs on top of an existing single-agent tool, and the experiments used GitHub Copilot CLI. The paper says small adapters could connect other tools, such as Claude Code.

What the benchmark shows

The test used ProgramBench, with its five hardest tasks: FFmpeg, gromacs, pandoc, PHP-src and ctags. In each, agents must rebuild a real program from watching how it behaves. They work offline and get six hours. The original codebases are large, from 2,767 files for pandoc up to 26,266 for PHP-src.

With GPT-5.6-sol at high reasoning effort, the average share of tests passed across the five tasks rose from 19.31% for one agent to 28.78% for 128 agents. That is a 9.47-point gain, about 49% in relative terms. The early steps were modest: going from 1 to 8 agents added just 1.37 points.

On pandoc alone, a single agent scored 33.89% and the 1,024-agent run reached 55.06%. More agents also got there faster. At the 30-minute checkpoint, 128 agents had already passed 30%, while smaller teams of 32 and 8 needed 60 and 90 minutes.

The project's README adds a newer model, GPT-6.1-sol. On pandoc, it rose from 56.19% with one agent to 79.59% with 32 agents. Those figures are not in the first version of the paper, so they are less documented than the rest.

Roles nobody assigned

The researchers read through the workers' trails at each team size and report that behaviors appeared on their own. With 8 agents, peers agreed on interfaces and sorted out overlapping claims between themselves. At 32, they reviewed each other's work, and one approval was withdrawn after someone found a counterexample.

At 128, workers kept going back to reviewers they trusted and settled on a common way to integrate changes. At 1,024, several workers acted as integrators, and peers picked up work that had failed. According to the source, none of these roles was written in ahead of time.

The gains also show diminishing returns. The 5-task average was still only 28.78% at 128 agents, so more agents did not make the hardest tasks easy.

What it takes to run, and what is missing

The release includes a one-machine setup using Docker Compose, plus a single-agent baseline for comparison. It runs on Linux with Docker and a recent Python, and you also need ProgramBench and a model API token. By default it launches eight workers, gives each task six hours, and uses GPT-5.6-sol. Each worker is capped at 272,000 tokens of input and 128,000 of output, and at 64 GiB of memory.

The 1,024-agent run was not a laptop experiment. It spread the agents over 16 machines, 64 agents on each.

The code uses the MIT license, which allows broad reuse. But the source says token cost is not disclosed, so nobody outside Microsoft can yet say what a large run costs. Results come from coding tasks that rebuild existing programs, so they do not automatically carry over to other kinds of work.