blog/content/posts-en/agensh.md

title, pubDate, category, tags, locked

title	pubDate	category	tags	locked
Agensh: Scaling Organizational Intelligence to 1,024 Agents	2026-11-01	tech	Paper Notes AI Collaboration	true

Multi-agent systems compress the latency of complex tasks through concurrency, but mainstream frameworks share one ceiling: the central orchestrator. Task allocation, progress aggregation, and result adjudication all squeeze through a single context — the bigger the scale, the sooner the orchestrator dies. In October 2026, Microsoft Research open-sourced Agensh — a self-organized multi-agent harness with no central orchestrator, and the paper Scaling Organizational Intelligence to 1,024 Agents pushed it to a thousand and twenty-four agents.

Its answer is disarmingly simple: instead of building a smarter scheduling brain, hand the agents the coordination infrastructure of a human organization, as is.

📄 Read the full paper PDF online →　·　arXiv 2609.26781　·　Microsoft Research

1. Three pillars: an organization's coordination infrastructure

Agensh provides exactly three pieces of infrastructure; everything else self-organizes:

• Shared workspace: a git platform carries the organization's in-progress and integrated work — branches, PRs, and merge conflicts, twenty years of human machinery reused as-is;
• Message interface: a team channel plus direct messages with priority delivery — organization-wide broadcasts and urgent collision resolution each take their own lane;
• Shared context: a typed-entry board holding the organization's findings and work intentions.

The open-source reference implementation runs Gitea for the workspace and Mattermost for channel and DMs — a fully self-hosted "office" with no proprietary services. No orchestrator assigns tasks: workers find work themselves in the workspace and the context board, claim it, verify it, and merge it. The natural bottleneck of scaling — that ever-busier hub — simply does not exist.

2. The cooperation loop: every worker runs their own lap

Every worker concurrently and asynchronously runs the same loop: gather context → claim a sub-task → take action → verify → merge progress. Gathering context means reading the shared workspace and the board's accumulated knowledge; claiming is a CLAIM declaration, with collisions resolved over direct messages; verification is running the tests yourself — evidence talks; merging goes through PRs.

The most interesting design is the economy of the shared context: entries are deliberately tiny (about 100 characters, 300 for PATCH_SUMMARY), with the long version in a detail field fetched on demand; board_read serves only the latest 2,000 entries, and anything older is reachable only through boolean search (, = OR, & = AND) — recent memory stays small, the long tail is searched. The paper calls FAIL the highest-value entry: one documented falsified path stops the whole team from re-burning budget on the same dead end. New entries are pushed to peers as higher-priority updates at their next tool-call boundary.

This shared context is not Agensh's invention — §2.3 of the paper states plainly that "the shared context follows the core idea of DeLM". DeLM (arXiv:2606.10662) ran decentralized multi-agent coordination through a shared context and task queue: its board is an append-only event log (items, claims, completions, FACT/FAIL notes, status) with bodies stored in a separate database beside the log, hard limits (≤40 files, ≤400 KB total), and a blocking read --wait that wakes when a peer posts. On a 10-task Terminal-Bench 4.0 subset, two agents coordinating through the shared context averaged +12.5 percentage points accuracy and a 1.78× speedup. Agensh scaled that thread to a thousand agents.

3. The numbers: does scaling actually help?

Two datasets answer "do more agents actually move the needle": on the five hardest ProgramBench tasks, 1 → 128 agents raised the pass rate from 19.31% to 28.78% (~49% relative); on building pandoc from scratch (6-hour budget, no Internet), 1 → 1,024 agents raised it from 33.89% to 55.06%. For problems where raw compute has hit diminishing returns, the marginal return of organization is still there.

Engineering readiness arrived too: v1.0 shipped on 2026-10-23, and v1.0.1 six days later supports Copilot, Codex, Claude Code, and Pi as the underlying single-agent harness — use whatever mainline model you like underneath. The open-source release is a single-node harness, and the v1.0 package ships with a reproduction guide, the paper, and a demo — from paper to runnable repository with no "coming soon" in between.

4. From paper to desktop: the story of one issue

For us this paper was never just on paper. After digesting it, on 2026-10-23 I filed issue #13 on the pi-mesh repository: pi-mesh already had the message interface (mesh_send, rooms, priorities) and the shared workspace (git + mesh_reserve), but lacked the third pillar, shared context — proposing board_write / board_read / board_grep in exactly the Agensh/DeLM shape.

The maintainer cgarrot's reply is the most instructive part of the story: the direction was right, but the hash-only ledger makes pi-mesh structurally incapable of being that board — embedding persistence in the broker would turn a router into a database. The right shape was a separate package: join the room as a normal peer, own your storage, and let the mesh keep routing. Thus pi-board: v0.1 landed within a day — 55 tests, zero failures, a nine-step smoke run on a real broker — and when the issue finally closed, the official pointer landed on it. The memory layer of the four-piece toolkit introduced in the previous post grew straight out of this paper.

5. Closing

Agensh's insight is not the number "1024" but its decomposition of organizational intelligence: workspace, messages, shared context — three pillars holding up self-organization, none of which needs a smarter brain. The decomposition holds at thousand-agent scale, holds for a local four-piece toolkit, and holds for a one-person shop with a few agent terminals. Scale changes; the pillars stay.

Related reading: Spec Harness in Depth · The pi-mesh Tool Family