Can a Company Survive Without a CEO?
Imagine this: you're dropped into a project team of 1,024 programmers and asked to build pandoc—a complex document conversion tool—from scratch, with delivery in 6 hours and no internet access. No project manager, no tech lead, no one telling you what to do.
You'd say: impossible.
But a Microsoft Research team did it. They let 1,024 AI agents spontaneously divide labor, collaborate, and verify each other's work without any central scheduler, ultimately raising pandoc's test pass rate from 33.89% (single agent) to 55.06%. The system is called Agensh.
The Central Orchestrator Bottleneck
Let's be clear about where the problem lies.
Current mainstream multi-agent frameworks—AutoGen, LangGraph, CrewAI—all rely on a "central orchestrator." This orchestrator is responsible for:
1. Breaking a large task into subtasks 2. Assigning subtasks to workers 3. Collecting worker results 4. Deciding what to do next
Sounds reasonable, right? Like a project manager coordinating everything in a company.
But the problem: the orchestrator itself is a bottleneck. It must simultaneously understand every worker's state, every subtask's progress, and all context. As workers scale from 8 to 32 to 128, the orchestrator's context window overflows and decision latency grows exponentially.
Analogy: a manager can handle 5 people, struggles with 50, and with 1,000? They can't make any decisions—reading status reports alone takes all day.
Agensh's Solution: Kill the Orchestrator
Agensh's core idea is brutally simple: no orchestrator.
Without a central scheduler, who assigns tasks? Answer: each worker assigns itself.
Every Agensh worker runs a "Multi-Agent Cooperation Loop":
1. Gather context: Read the shared workspace to see what tasks exist, what's done, what's in progress 2. Claim a subtask: Judge which task needs doing, assign it to yourself 3. Act: Write code, run tests, fix bugs 4. Share findings: Write results back to the shared workspace 5. Verify: Other workers can check your work 6. Merge progress: Integrate results into the main branch
It's like an open-source project without a manager: everyone looks at the issue list, claims one, submits a PR, others review, and it gets merged.
Three Infrastructure Components
"Self-organization" alone is too vague. Agensh provides three concrete infrastructure components:
1. Shared Workspace
This is the "kanban board" for all workers, with three task categories:
- proposed: suggested but unclaimed
- ongoing: currently being worked on by some worker
- completed: finished
2. Message Interface
Workers need to communicate: "I'm on this module, don't duplicate" or "Your code has a bug on line 42." The message interface enables asynchronous communication—no waiting for replies.
3. Shared Context
This is "team memory." Important findings, decisions, and pitfalls are stored here. Newly joined workers can quickly read this context instead of starting from scratch.
Results: Evolution from 1 to 1,024
Agensh was tested on ProgramBench's 5 hardest tasks using the GPT-5.6-sol (high) model.
The Numbers
| Agents | Average test pass rate | Relative gain | |:---:|:---:|:---:| | 1 | 19.31% | baseline | | 128 | 28.78% | +49% |
On the pandoc task, scaled to 1,024:
| Agents | pandoc test pass rate | |:---:|:---:| | 1 | 33.89% | | 1,024 | 55.06% |
A 55% pass rate means: more than half the test cases passed—building a real-world complex tool from scratch, in 6 hours, with no internet.
The Most Interesting Finding: Self-Organization Is Emergent
The paper's most fascinating part isn't the numbers—it's the analysis of worker behavior trajectories. As agent count increases, different forms of self-organized cooperation emerge and standardize:
8 agents: Peer Coordination
Workers start greeting each other: "You're doing this? Then I'll take that." Simple division of labor appears, but it's still crude.
32 agents: Cross-Worker Integration Management
Some workers begin proactively acting as "integrators"—merging multiple workers' code and handling conflicts.
128 agents: Workflow Standardization
Teams spontaneously form standardized workflows. "Write tests before implementation" becomes consensus; "run lint before committing" becomes convention. Nobody mandates these standards—they emerge.
1,024 agents: Role Specialization
At scale, workers spontaneously specialize. Some focus on writing tests, some on fixing bugs, some on code review, some on documentation—like a mature company with formal job roles.
Why Does This Matter?
1. Agent count as a new scaling dimension
We're used to the scaling law "bigger models are stronger." But Agensh reveals another dimension: with fixed model capability, increasing agent count also scales intelligence.
Like human society: one genius working alone can't outproduce 100 ordinary people collaborating. The key isn't individual capability but organizational efficiency.
2. Decentralization is an engineering necessity, not a theory
Prior multi-agent research mostly stayed at 8–16 agents because central orchestrators couldn't handle more. Agensh proves decentralization isn't an academic ideal—it's the engineering requirement for breaking the scale barrier.
3. Self-organizing behavior can emerge
Most exciting: nobody taught these agents how to divide labor. They simply claimed tasks in a shared workspace and shared results—and division of labor appeared naturally. This echoes self-organization in biological systems: ant colony task allocation, neural specialization.
An Honest Assessment
Agensh is not a silver bullet.
First, a 55% pass rate means 45% of tests still fail. Building pandoc from scratch is an extremely hard task, but Agensh is far from "replacing human engineers."
Second, 1,024 agents aren't cheap. Even if each agent uses only a fraction of GPT-5.6-sol tokens, the API cost of 1,024 concurrently running agents is substantial. The paper doesn't discuss cost-effectiveness in detail.
Third, the coordination overhead of decentralization is non-trivial. Workers frequently read the shared workspace, send messages, and verify results—all extra token consumption.
But these issues don't diminish the core contribution: Agensh demonstrates that decentralized multi-agent systems can scale to unprecedented sizes, and that self-organizing behavior emerges with scale.
Implications for the Future
Agensh raises a deeper question: is human organizational structure also limited by the bandwidth of a "central orchestrator"?
A CEO can only manage so many direct reports, so company size has limits. Beyond a certain scale, companies must split, decentralize, and let divisions self-govern. Multi-agent AI systems are retracing this path.
From "peer coordination" at 8 agents to "role specialization" at 1,024, this evolutionary trajectory mirrors human organizational development strikingly. Perhaps self-organization isn't a special mechanism but an inevitable emergent result of any sufficiently complex cooperative system.
If so, Agensh's significance extends beyond AI—it's an experimental exploration of "organizational intelligence" itself.
---
Paper: Agensh: Scaling Organizational Intelligence to 1,024 Agents
Project page: https://agens-harness.github.io/project/