Microsoft open-sources Agensh, a harness that ran 1,024 coding agents with no manager

Microsoft releases Agensh

Microsoft Research has open-sourced Agensh, a harness that lets large teams of AI coding agents work on one codebase without a manager agent telling them what to do. The code went up on 24 October 2026 in the microsoft/Agensh repository on GitHub under the MIT License, together with the launch scripts and a reproduction guide for the team's experiments.

The research behind it is not brand new. The authors, Zhihao Zhan, Ting Song, Li Dong, Shaohan Huang, Jianxun Lian, Yan Xia and Furu Wei, posted the Agensh preprint on arXiv on 22 September under the title Agensh: Scaling Organizational Intelligence to 1,024 Agents. What changed this week is that anyone can now inspect the code, run it and check the numbers.

The headline claim is about scale. Microsoft says Agensh coordinated 1,024 agents on a single software task within a six-hour budget, and that results kept improving as the team grew. Most agent products in use today run a handful of agents at a time.

Why remove the orchestrator

Most multi-agent systems follow an orchestrator and worker pattern. One lead agent breaks the job into pieces, hands them out, collects the results and decides what happens next. That is easy to reason about, but the paper argues it also caps how far a team can grow, because every decision has to pass through one agent with one context window.

Agensh removes that bottleneck. There is no lead. Every worker gets the same prompt, differing only in its ID, and decides for itself what to work on next based on what the rest of the team is doing. Coordination happens through shared infrastructure rather than through a boss.

The opposite advice is also circulating. Anthropic recently told enterprises to fold subagents into a single agent loop for most jobs, arguing that extra agents add cost and lose context. Agensh is a bet on the other end of that trade: very large, long jobs where parallel work pays off.

How the cooperation loop works

Each worker repeats the same five steps, concurrently and without waiting for the others:

• Gather context: read the goal, peers' progress, messages and recorded findings.
• Claim a sub-task: post a claim and settle any overlap with the peer concerned.
• Take action: work locally with tools and share useful findings early.
• Verify results: check the work against the sub-task's acceptance criteria.
• Merge progress: merge into the shared repository, post an update and start again.

Three shared services hold it together

Three services connect the workers. Gitea, a self-hosted Git platform, is the shared workspace, with branches, pull requests and visible merge conflicts. Mattermost, an open-source chat tool, carries a team channel and direct messages for urgent collisions. A shared context board, adapted from an earlier project called DeLM, stores typed notes such as observed behaviour, established facts, failed attempts, work claims and patch summaries, so agents do not repeat each other's dead ends.

The loop itself lives in the prompt rather than in special runtime code, and it sits on top of an existing single-agent harness. In Microsoft's experiments that was GitHub Copilot's command-line agent. MarkTechPost, which covered the release, notes that the paper says thin adapters could connect other harnesses such as Claude Code, though the release ships with Copilot.

The ProgramBench results

Microsoft tested Agensh on ProgramBench, a Meta research benchmark in which agents must rebuild a real program from scratch using only the compiled binary's behaviour and its documentation, with internet access switched off so they cannot download the original code. The team picked the five tasks that state-of-the-art models find hardest: FFmpeg, gromacs, pandoc, PHP and ctags. Their reference codebases range from about 2,800 files for pandoc to more than 26,000 for PHP.

Using OpenAI's GPT-5.6-sol at high reasoning effort and a six-hour budget per task, the mean final test-pass rate across the five tasks rose from 19.31 percent with one agent to 20.68 percent with 8, 26.52 percent with 32 and 28.78 percent with 128. That is a gain of 9.47 points, about 49 percent in relative terms.

Pandoc is where the team pushed furthest. One agent reached 33.89 percent; 128 agents reached 50.94 percent; 1,024 agents reached 55.06 percent. Bigger teams also got there faster: on pandoc, 128 agents passed 30 percent within 30 minutes, while 32 and 8 agents needed 60 and 90 minutes and a single agent never crossed it in the first two hours.

The repository adds a newer result that is not in the preprint. With GPT-6.1-sol, pandoc went from 56.19 percent with one agent to 79.59 percent with 32, a relative gain of 41.64 percent.

Roles nobody assigned

The most interesting part of the paper is qualitative. Because every agent starts identical, any structure that appears has to come from the agents themselves, and the authors say structure did appear as teams grew.

With 8 agents, workers agreed on interfaces and built modules to fit them, and resolved overlapping claims by talking it through. At 32, groups jointly reviewed contributions; in one PHP case an approval was withdrawn after another worker found a counterexample, and the code was fixed and re-reviewed. At 128, workers started choosing reviewers based on past experience and agreed a standard integration protocol that others then copied. At 1,024, several workers acted as dedicated integrators, and specialists could pick up a task when a peer's attempt failed.

That is a more upbeat picture of large agent groups than some recent work. General Reasoning found that its Avalon-M1 agent teams got better at tasks but reported less to humans as training went on. Agensh's paper describes self-organisation, not oversight, and does not test how a human would supervise a thousand agents.

Running it yourself

The reproduction guide makes clear this is research infrastructure, not a product. It needs Linux with Docker Compose, systemd and cgroup v2, passwordless sudo for Docker, the ProgramBench evaluator installed separately, and an OpenAI-compatible model gateway. The defaults are 8 workers, six hours per task, GPT-5.6-sol at high effort and a 272,000-token prompt window.

Workers run in containers whose network only reaches the model endpoint, and each can execute the reference program without reading its bytes. Agents share one peer role; pull requests can merge with zero required approvals while direct pushes to the main branch are restricted, and the CI merge gate is disabled. The guide also says the historical runs used an older reference build, so these differences rule out an exact historical reproduction and new runs should record their own setup.

Agensh joins a run of open agent infrastructure releases, including AWS's Infinity runtime for keeping thousands of idle agents cheap. Infinity is about agents that mostly wait; Agensh is about many agents working at once on the same code.

How it compares with other agent teams

Commercial tools mostly keep a lead agent in charge. MarkTechPost's comparison lists Claude Code agent teams with a fixed lead session and three to five teammates recommended, Kimi Agent Swarm with up to 100 sub-agents under an orchestrator, and Copilot CLI's fleet mode, where Copilot assigns parts to subagents. Agensh is the only one in that table with no orchestrator and a tested team of 1,024.

That does not make it a drop-in replacement. Those products are designed for everyday developer tasks; Agensh was built and measured on six-hour, offline rebuilds of large programs, with a full Git server and chat system per run.

What the results do not show

The figures are Microsoft's own, on five tasks from one benchmark, and AI Lookout has not reproduced them. The gains are real but uneven: going from 1 to 8 agents moved the five-task mean by only 1.37 points, and the biggest jump came between 8 and 32. Even at 1,024 agents, pandoc passed about 55 percent of tests with GPT-5.6-sol, so the rebuilt programs remain incomplete.

The paper does not report what the runs cost in tokens or money. A thousand agents each running a frontier model for six hours is expensive, and the newer GPT-6.1-sol result shows a better single model can beat a large team of an older one: one GPT-6.1-sol agent scored higher on pandoc than 1,024 GPT-5.6-sol agents. For teams deciding where to spend, that comparison matters as much as the scaling curve.

It also leaves open how the approach transfers to messier work, such as changing an existing codebase with real users, where the right answer is not defined by a reference binary. The open release is what makes those questions testable by people outside Microsoft.