1,024 AI Agents. Zero Human Code Reviews. I Read Microsoft's Fine Print.

Microsoft Research threw over a thousand AI agents at one codebase, and a single agent on a newer model edged past the whole team. That same team merged its own code, and no human approved a single change. The rules allowed merges with zero required approvals, the CI merge gate was off, and the agents ended up reviewing each other. So what does a thousand-agent swarm actually buy you? I read the paper, the repo and the fine print.

What Microsoft shipped

It's called Agensh, from Microsoft Research. The paper came out on September 22. CONFIRMED · ARXIV The code went public about a month later under the MIT license: the v1.0 release was tagged October 23, and the README says it was open-sourced on October 24. On October 29, v1.0.1 added Claude Code, Codex and Pi alongside Copilot, the original backend. CONFIRMED · GITHUB RELEASES A v1.0.2 followed on October 31.

Agensh sits on top of an agent you already use. Each of those single-agent harnesses runs one worker's own loop. Agensh is the organization layer above them: it handles everything between the workers, meaning identity, messages, shared notes and merging. CONFIRMED · PAPER

Here's the surprising part. The teamwork rules live in the prompt. Every worker gets the same prompt, with only its ID changed. CONFIRMED · PAPER One line from the prompt in the paper's appendix sums it up:

1024 coders, all equal. You claim what to build, you build it, you merge it, and you choose the next thing.

The leaderless loop

Each worker runs five steps on repeat:

1. Gather context.
2. Claim a sub-task.
3. Do it.
4. Verify it.
5. Merge it.

Three shared pipes connect the workers. Gitea is the shared repo. Mattermost is the chat. And a shared board holds short typed notes, most capped at 100 characters, in a design the authors adapted from DeLM. CONFIRMED · REPO

Those notes do the coordinating:

• CLAIM says "I'm on this."
• FACT and OBSERVED share what someone found.
• FAIL records a dead end. The prompt calls it "the highest-value entry," because it stops peers spending budget on it. CONFIRMED · PAPER

When two claims overlap, the workers settle it by direct message. When a merge is refused, whoever hit it merges the latest main, re-checks and pushes again.

So who tells them it's time to stop? The harness does. In my reading, "no orchestrator" means no planning agent, while the infrastructure still runs the clock. It staggers start-up (one worker every 30 seconds for the first hour, then one every 3 seconds), nudges idle workers after ten minutes, and sends deadline reminders at 45 and 5 minutes before the end. CONFIRMED · PAPER

Who reviewed the code

This is where the title comes from. No human approved anything: the worker prompt's first rule says the run is fully autonomous with no external input, and the merge rules allowed merges with zero required approvals. CONFIRMED · BY DESIGN The work cycle in the prompt has no review step either. The authors read the logs anyway, and say peer review showed up on its own as the team grew: CONFIRMED · PAPER

• At 32 agents, on the PHP-src task, several peers approved a change, and the approval was withdrawn when another worker found a counterexample. The author fixed it, peers re-reviewed, and a peer merged it.
• At 128 agents, on pandoc, two workers set up a review-and-merge protocol (update and test a branch, then send the commit hash to a peer to validate and merge), and other workers reused it.
• At 1,024 agents, several workers served as integrators.

So the agents did review code. Each other's. No human signed off. That's the authors' reading of the trajectories, so treat it as their interpretation.

The fine print

The benchmark is ProgramBench: rebuild a real program from scratch, mostly by running its binary, offline, within six hours. CONFIRMED · PAPER

Microsoft Research says the average across ProgramBench's five hardest tasks rose from about 19% with one agent to about 29% with 128 agents. FIRST-PARTY · MICROSOFT RESEARCH The five-task average stops at 128.

The 1,024 result covers one of those tasks, pandoc. One model (GPT-5.6-sol on high), one reported result, from a six-hour budget. FIRST-PARTY · MICROSOFT RESEARCH

Agents	Pandoc pass rate (GPT-5.6-sol high)
1	33.89%
8	41.75%
32	43.11%
128	50.94%
1,024	55.06%

Now look at the top of that curve. Going from 128 agents to 1,024, eight times the agents, added about four points (4.12, per the paper).

That 1,024 run used sixteen machines with 64 agents each. CONFIRMED · PAPER The public release is a single-machine Docker Compose setup, with eight workers by default. CONFIRMED · REPO

Here's what the paper leaves out:

• The token bill. No cost figures appear in the paper, the README or the project page. UNKNOWN
• How many times each setup was run. No run counts, no error bars. UNKNOWN
• An independent reproduction. None has been published that I could find. UNKNOWN

And the merge rules again. Per the released harness's REPRODUCE.md, the bootstrap "allows PR merges with zero required approvals while restricting direct pushes to main; the CI merge gate is disabled." CONFIRMED · REPO

A newer model beats the swarm

The Agensh README also reports runs on a newer model, GPT-6.1-sol. On pandoc, one agent scored 56.19%, eight agents 71.38%, and 32 agents reached about 80% (79.59%). FIRST-PARTY · MICROSOFT RESEARCH No 128 or 1,024 runs are reported on that model.

Put those side by side. One GPT-6.1-sol agent, at about 56%, edged past the whole 1,024-agent GPT-5.6-sol run, at 55%. That's one reported result each, and the GPT-6.1 figures come from the README, while the 1,024 figure comes from the paper.

The independence question

One GitHub issue, #12, raises a fair point. Every worker is the same model, so the peer review is one model checking its own kind of work, and their mistakes can line up. REPORTED · GITHUB ISSUE It was written by a vendor with a product to sell, so weigh that.

Can you run it?

The requirements, from REPRODUCE.md: CONFIRMED · REPO

• Linux with systemd and cgroup v2
• Docker Engine with Compose v2
• Passwordless sudo
• Python 3.11+ and uv
• ProgramBench installed (the release was validated on v1.2.5)

You bring your own model gateway and key. Copilot, Pi and Codex talk to a Responses API endpoint, and Claude Code talks to the Anthropic Messages API. Preflight makes a small live model request before anything starts.

I haven't run it myself: I'm on a Mac, and every worker bills your API for up to six hours. Even the default eight-worker team costs real money, and nobody has published how much.

The replay of the 1,024-agent run is free to watch on the project page: agens-harness.github.io/project/replay.html.

What I built from it: zStack

In my view, Agensh answers one question really well: how far can one repo go in six hours if you add agents?

My days look different. Several projects, several GitHub accounts, and dozens of pull requests going through real CI every day. In that world, spot runners get reclaimed mid-job. Default Linux runners on private GitHub repos have two CPUs. And with a hundred PRs open, main moves before your branch lands.

So I built zStack (say "Zee Stack"). It's a free, open-source agent skill, MIT licensed, and it borrows from a few open-source projects:

• Lauren Tan's pstack (MIT): route every goal to a named playbook, and make the agent cite the principle behind each decision.
• Agensh: a shared FAIL board for dead ends, claims that expire, and a staggered start.
• David Ondrej's agent-orchestration skills, in part.

Michael Denyer's pstack-claude (MIT) is credited too. zStack's wording and code are original.

Here's what it adds for real teams:

• Sibling sweeps. By default, every fixed bug triggers a sweep for its siblings, across the repo and any sibling repos you list.
• Evidence packets. Every PR carries checks recorded at the head commit and a how-to-test block. When zStack merges, the merge is pinned to that verified commit, one at a time per repo.
• A trust ladder. Out of the box, zStack opens pull requests and you merge them (draft-only for migrations, auth, infra and payments). It merges on its own only after you raise its level, per repo and per kind of change, and a revert drops it back a level.

Get zStack core here: github.com/simsketch/zstack.

For many repos and accounts, there's zstack-fleet: an accounts doctor, a CI budget and runner lint, spot-reclaim retries, a drift score, and batch planning. It's a download for Premium members of the 500x Engineer Skool, which is a paid tier. Full fleet waves also need my VIP orchestrator, which is a higher paid tier.

It's new. I've tested it in Claude Code and Codex, and I'll report back on what holds up. These are tools, and what you get out of them depends on your own work.

The verdict

This section is my opinion.

Real and open. Agensh is real, open and readable. A team of agents with no boss scaled to 1,024, and the score kept rising on one task.

Narrow evidence. That 1,024 number is one task, one model and one reported result, with no cost published.

No human approvals. That was a lab condition, and the agents ended up reviewing each other.

Worth reading. Read the worker prompt in the paper's appendix. It's the best free lesson on multi-agent coordination I've read this month.

Fix the pipe first. If your bottleneck is CI and review, adding agents makes the queue longer.