Trend Watch: Agent Teams Have Reached a Thousand, and Coordination Is Becoming Infrastructure

Until recently a multi-agent system usually meant a handful of agents. This week's evidence describes teams in the hundreds or thousands, and at that size the hard part is no longer prompting each agent. It is giving them a shared state, a safety boundary and a server that can keep up.

Four signals from one week

A thousand agents on one proof. Anthropic's engineering post describes 1,000 agents on an early Fable 5.2 reproducing a Lean formalization of Fermat's Last Theorem in 28.7 hours. A single shared machine "hit its limits at about 100 agents", so each agent got its own virtual machine, coordinating only through Git and a shared Postgres database. The lead agent built its own tables for orders, assignments and notes, and the final task tree reached 2,418 tasks up to 10 levels deep.
Reviewer fleets. In a launch-page testimonial, an Uber engineer describes a 10 to 12 hour audit that "sent out about 170 reviewer agents".
Small teams beat one big one. A November 6 paper finds that with a 27B model and a budget of 100 agents, parallel teams of ten beat independent agents on 10 of 12 tasks, and beat one team of 100 on all four tasks where that was tested.
Servers that fall into a trap. Another November 6 paper shows that a 200-session burst can push an engine into a state where every agent turn misses the prefix cache, at a load it previously handled. That happened in all 30 burst runs, and a cap on concurrent sessions rescued 9 of 9 established traps without shedding load.

What scale changes

The Anthropic post is most useful for its safety design. Agents had no messaging tool, could push only to their own branch, and ran without network access in hardened sandboxes. Each tool call passed a classifier first, and a gateway stamped each request with the agent's identity outside the sandbox, "to prevent one agent from posing as another". Across more than a million tool calls, none met the bar for a block. A system that large cannot rely on reading transcripts, so the controls must be structural.

The two papers add a cost view. Bigger teams stop paying off, and many agents returning to the same long context at once can defeat the cache that makes them affordable. Coordination now has throughput limits, failure modes and a budget, like any other piece of infrastructure.

What remains uncertain. Anthropic calls its run "a toy experiment", run once, on a problem whose answer was already known and machine-checkable. Most business work has no Lean checker. The two papers are preprints, one testing a single 27B model and the other two engines.

Analysis: Start small and build the plumbing first. Before Geetha's team at Belgavi's Book Store runs more than a few agents over the CASE backlog, give them one shared task table with claims and status, identities assigned outside the agent, and a limit on concurrent sessions per model server. Compare five small teams against one large team on last month's cases before scaling either. Growing the number of agents is the easy part; keeping them coordinated and affordable is where the effort goes.

Sources and evidence

Agent teams now reach hundreds or thousands: Anthropic's 1,000-agent Lean run coordinated through Git and Postgres, and a tester sent out 170 reviewers. New papers find many small teams beat one large team, and session bursts can leave prefix caches missing every turn. Build shared task state, external identity and session caps before adding agents.