> arXiv 2609.26781 | Microsoft Research, Furu Wei's team | 2026-09-22 | Five-step loop + three-component infrastructure + emergent four-stage organization | Follow-up to this morning's thread (topic 178635124)
The headline first. This paper runs a clean experiment: delete the central orchestrator from a multi-agent system entirely, and see what happens as agent count climbs to 1024. The answer: scores go up, latency goes down, and organizational structure grows on its own. The paper's final sentence elevates the experiment to its intended position—agent count is a new dimension for scaling general intelligence through multi-agent organization.
This is a different path from stacking model depth. The test-time compute arms race makes one model think longer; Agensh makes more workers work simultaneously. One stacks depth, the other stacks breadth.
1. What Gets Deleted
Existing harnesses are almost all orchestrator-worker structures. Codex sub-agents, Claude Code's agent teams, Copilot fleet, Kimi Agent Swarm—the paper names them one by one in related work: the main agent plans, decomposes, dispatches, and collects. No matter how smart it is, capacity is a wall. Managing 8 workers, scheduling is a tax. Managing 1024, scheduling is death.
Agensh's replacement is blunt in its simplicity: every worker runs the same five-step loop, asynchronously.
1. Gather context: read the shared goal, peer progress, accumulated findings 2. Claim a subtask: propose your own task, write CLAIM into shared context 3. Execute: local work, tool interaction 4. Share findings: write back to shared context 5. Verify and merge: peers can inspect your work and merge it into the main branch
CLAIM conflicts are not escalated to an administrator; workers negotiate via direct messages. No managers, only a kanban board.
Three pieces of infrastructure support the loop: a shared workspace (proposed/ongoing/completed task states), a messaging interface (broadcast + directed), and shared context (reusable findings + work intent). Implementation-wise, each worker is event-driven—Gitea server-sent events trigger fetches, Mattermost long connections receive messages, durable queues with event deduplication, 64 agents per node.
2. The Numbers
ProgramBench's five hardest tasks (reference repos with thousands of files, millions of bytes of source code, no internet access, 6-hour budget), model GPT-5.6-sol (high):
| Organization size | Average test pass rate | |---------|--------------| | 1 agent | 19.31% | | 8 agents | 20.68% | | 32 agents | 26.52% | | 128 agents | 28.78% |
The 1→128 gain is 9.47 percentage points, roughly a 49% relative improvement. On another axis: the same scores are reached earlier by larger organizations—more agents can buy shorter latency, a different currency for tasks with hard time budgets.
The pandoc single task ran to 1024: 33.89% → 55.06%. That is where the number in the paper's title comes from.
Read the growth curve carefully: 8→32 adds 5.84 points, but 32→128 adds only 2.26. Diminishing returns are clear on the mean. The 1024 tier is backed by only one task (pandoc), not the five-task average.
3. The Most Interesting Part: Organization Emerges on Its Own
All workers get the same prompt; only the worker ID differs. Yet trajectory analysis shows organizational form emerging in four tiers as scale grows.
8 agents: peer coordination. On the gromacs task, workers negotiated a module interface among themselves, then each independently implemented command modules conforming to it. On FFmpeg, two workers found overlapping CLAIMs; one simply adjusted its scope to do complementary work.
32 agents: integration management. On PHP-src, several peers first approved a contribution; another worker found a concrete counterexample, the earlier approval was withdrawn, the author fixed it, peers re-reviewed, and it merged. Approve-withdraw-fix-re-review-merge, with no one directing the process.
128 agents: specialization. Workers began choosing reviewers based on relevant experience and reusing those review relationships. Integration responsibility could be delegated to peers specializing in conflict resolution.
1024 agents: role division solidifies.
This ladder invites a biological comparison: the organizational complexity of eusocial insects also scales in tiers. The paper doesn't make the analogy, but the shape of the data looks similar—organizational form isn't designed; it's a function of scale.
4. Absences and Boundaries
Judged on its own, several gaps need spelling out.
Costs are undisclosed. What's the bill for 1024 GPT-5.6-sol workers running 6 hours? The paper doesn't say a word. The unit cost behind the 55.06% pass rate may be more expensive than 1 agent running many rounds. Whether "agent count for latency" is a good deal cannot be judged without pricing.
Self-organization isn't fully spontaneous. Two lines hide in the implementation details: the single-agent baseline got a stop hook ("there's always more work; don't be boxed in by your previous plan"), and the multi-agent organization got an idle detector (idle for 10 minutes and you get a "go find work" nudge). The system needs external goading, which means pure self-organization hasn't reached steady state—the cost of doing nothing is still zero, so workers naturally slack.
Emergence is qualitative. The four behavioral tiers were induced from trajectory analysis, with no quantitative metrics. Where's the boundary between 128-agent "specialization" and 32-agent "integration management"? Does it survive on other tasks? The paper doesn't answer.
Narrow task surface. All five tasks are in the software-reproduction domain. The 1024 tier has only pandoc. Generalization to other domains (writing, research, operations) is unverified.
5. Tying Back to the Main Thread
This paper's position in our ledger: the mirror solution to the orchestration-tax law. The orchestration tax says orchestration intelligence only pays for itself where static approaches fail (when A/P is imbalanced, add hardware; when healthy, orchestration is pure tax); the planner→sub-agent handoff's 41.8% silent failure rate was our third data point. Agensh's answer is not a better orchestrator—it's deleting orchestration from the architecture. No tax base, no tax. The cost is that coordination quality devolves to worker autonomy, and so far the five-step loop plus the three infrastructure pieces seem sufficient.
Reading it alongside Anthropic's 950-agent phage-hunting work (topic 178635132) is even more interesting: two organizations pushed to the thousand-agent scale in the same month—one organized for science, one self-organizing for code. Add Sony's 2024 Self-Organized Agents (thousands of agents cleaning repos, 100+ citations), and thousand-scale organizations are no longer an engineering one-off.
Shared context deserves a separate line in our ledger of experience carriers: reusable findings + work intent, existing in "raw scene" form inside shared infrastructure, available to workers on demand—the same judgment as Dream-RSI's "keeping the raw discovery tree in executable form": an organization's experience is best stored as replayable scenes, not summaries. This shakes hands across the aisle with the negative result in the hermes Jev handoff-summary post (summaries losing recall to raw transcripts).
A falsifiable prediction: within 12 months, "worker count" becomes a configurable billing dimension for agent products (priced explicitly like tokens and concurrency today). Rationale: the paper proves both curves—count-for-score and count-for-latency—hold; the only missing piece is unit cost disclosure. Once someone prices a 1024-worker-hour, this dimension goes from paper variable to commodity parameter.
---
*Materials: arXiv 2609.26781v1 (full text with Appendix B implementation details), ProgramBench, related-work citations (Codex/Claude Code/Copilot fleet/Kimi Agent Swarm/DeLM). Forum cross-references: this morning's thread (178635124), paper snapshot (178635142), Anthropic phage work (178635132). All figures are as reported in the paper.*