Microsoft's Agensh Lets 1,024 AI Agents Work Together Without a Boss

What it's about

Microsoft Research has open-sourced Agensh. In tests, the system coordinated up to 1,024 AI agents working on the same code repository at the same time, with no lead agent handing out tasks. A harness is the runtime environment around a language model: it supplies tools, memory and context management. Agensh is a harness built for many agents at once. Its core idea is to drop the orchestrator (the coordinator). The details come from a report based on the paper and the project page, so they are essentially vendor claims.

How a team without a boss works

In typical multi-agent systems, a central agent plans, distributes work and merges results. With Agensh, every worker runs simultaneously and asynchronously, picks its own subtasks and coordinates directly with the others. Each agent goes through five steps:

1. Gather context: read the goal, the others' progress, messages and findings.
2. Claim a subtask: post a CLAIM and resolve overlaps by direct message.
3. Execute: work with local tools and share useful findings early.
4. Verify: test the result against the subtask's acceptance criteria.
5. Merge: integrate changes into the shared repository, post an update and start over.

Three services support the shared work: Gitea hosts the repository, branches and pull requests, Mattermost provides a team channel and direct messages for resolving conflicts, and a context board stores typed notes such as observations, facts, errors, claimed tasks and change summaries.

Notably, the coordination logic lives in the agents' prompt, not in the execution code. All workers get essentially the same instructions; only the ID differs. Agensh builds on a single-agent harness; the experiments used GitHub Copilot CLI via ACP sessions. According to the team, lightweight adapters could connect other environments such as Claude Code.

Results on ProgramBench

The team tested the five hardest ProgramBench tasks: FFmpeg, GROMACS, pandoc, PHP-src and ctags. The job is to rebuild a program from its observed behavior; the agents work offline for at most six hours. The projects differ widely in size: the pandoc reference repository has 2,767 files, PHP-src has 26,266.

With GPT-5.6-sol at high reasoning effort, the mean test pass rate across all five tasks was:

That is 9.47 percentage points more, or about 49% in relative terms. Going from 1 to 8 agents, however, added only 1.37 points. For pandoc, the only case with numbers for every level, the results were 33.89% (1), 41.75% (8), 43.11% (32), 50.94% (128) and 55.06% (1,024). Speed improved too: with 128 agents, over 30% of tests passed after 30 minutes. With 32 agents that took 60 minutes, and with 8 agents 90.

The project page also cites a measurement with GPT-6.1-sol that is missing from the first paper: on pandoc, the rate rose from 56.19% (1 agent) to 79.59% (32 agents), a relative gain of 41.64%. These figures belong to a different model and shouldn't be mixed with the rest.

More agents, more success?

Not automatically. The clearest gain comes from going from 8 to 32 workers; after that, progress becomes more modest. The team reads the results as evidence that distributed collaboration can lift performance in these tests, not as a guarantee that scaling removes a model's limits.

The roles that emerged as the group grew are interesting, since none were pre-programmed:

• 8 agents: agreed on interfaces and resolved overlapping claims on their own.
• 32 agents: reviewed shared work and withdrew an approval after a counterexample turned up.
• 128 agents: reused trusted reviewers and standardized an integration protocol.
• 1,024 agents: some took on integration tasks, while others helped salvage failed work.

Comparison and context

According to the team, Claude Code Agent Teams use a fixed leader and recommend three to five agents, Kimi Agent Swarm uses an orchestrator with up to 100 subagents, and Copilot CLI names no limit. That isn't a like-for-like performance comparison, since architectures, models and test protocols all differ.

The report mentions further developments: according to InfoQ, Microsoft's Agent Framework became generally available on April 2, 2026, with the Agent Harness following in June. An analysis by MBZUAI's VILA-Lab estimated that about 98.4% of the code in Claude Code v2.1.88 is harness infrastructure. According to GeekWire, Microsoft's MDASH system with over 100 agents reached 88.45% on CyberGym (self-reported). UiPath showed an orchestration layer called Maestro Flow, and Sakana AI quotes roughly $5 per million input tokens and $30 per million output tokens for Fugu Ultra.

What you need to try it

Agensh is a research and developer tool, not a model you download. The reference setup runs on Linux with Docker Compose, by default on one node with eight workers, six hours per task and GPT-5.6-sol. You need Docker Engine, Compose v2, systemd, cgroup v2 and Python 3.11 or newer, plus an API token for the model. The 1,024-agent run needed 16 nodes with 64 workers each and up to 64 GiB of memory per worker. Each worker is limited to 272,000 input and 128,000 output tokens. ProgramBench v1.2.5 is validated. License: MIT.

Takeaway

Agensh shows that teams of agents can organize themselves without a boss, as long as the shared environment (repository, channel, note board) is right. For development teams, it offers a hint about where extra agents pay off: the gain from 1 to 8 was small, and from 8 to 32 it was largest. Plenty remains open: the results hold for specific combinations of model, task and agent count, token costs weren't disclosed, and the absolute pass rates (under 30% on average) are low. A human look at what lands in the repository is still a good idea, especially since even peer review only fixed a mistake once a counterexample appeared. If you try it, measure the cost per point of improvement first.