📑 Table of contents

Replit: 32 Claude Opus 5.5 agents in a swarm make NumPy 18.9x faster — but topology matters more than the model

Agents IA 🟢 Beginner ⏱️ 15 min read 📅 2026-11-20

Replit: 32 Claude Opus 5.5 agents in a swarm make NumPy 18.9x faster — but topology matters more than the model

🔎 A swarm of 32 agents, 2 hours, and a result that gets people talking

On November 19, 2026, Replit published an experiment on its Frontier blog that will fuel debates for weeks: a single Claude Opus 5.5 agent, tasked with optimizing NumPy, achieved a 3.7x speedup in 2 hours. The same agent, deployed as a swarm of 32 instances, reached 18.9x — in exactly the same time, with the same hardware constraint per agent.

The headline number is the 18.9x. But the number that should really interest teams building multi-agent systems is a different one: Replit's best-performing swarm had a coordinator that never sent a single direct message to a worker. Zero. All coordination went through a shared task board.

Why now? Because the literature on multi-agent systems has so far been rather disappointing. The MAST study (Cemri, Pan, et al.) noted that multi-agent gains on popular benchmarks are often minimal. CooperBench (Khatua, Zhu, et al.) showed that cooperating agents lose about 30% success rate compared to their individual execution. Replit provides the first large-scale, quantified counterexample of what makes a swarm work — and it's not the model.


The Essentials

  • 1 Opus 5.5 agent = 3.7x on NumPy in 2 hours; 32 Opus 5.5 agents = 18.9x in the same time. Self-reported result by Replit, not yet independently reproduced.
  • GPT-6.2 Astra was the best solo agent tested, but its swarms degrade as the team grows. Solo rank is a poor predictor of swarm rank.
  • Topology is the decisive factor: winning swarms send 82% of their messages to a shared board (one thread per workload) and ~1.4 direct messages to the coordinator. Those that fail route everything through the coordinator, whose inbox explodes.
  • The shape of the codebase matters as much as the architecture: NumPy (13 independent workloads) lends itself to parallelism; Git (7 workloads across 15 files) resists swarms.
  • Serious methodology: 14 open source libraries, 4 swarm sizes (1, 8, 16, 32), 6 models, network disabled, post-execution audit, isolated microVM per agent.

Tool Main use Price (November 2026, check the official site) Ideal for
Replit Missions Deploying agent swarms on defined objectives (Mission Agreement, budgets, human approvals) Core subscription + usage-based compute cost Teams that want to test multi-agent without setting up infrastructure
Claude Opus 5.5 Worker agent in high-performance swarms Usage-based API subscription Parallelizable workloads, performance engineering
Agent Habitat Isolated Linux microVMs per agent, swarm orchestration Included in Replit's Frontier offering Reproducing the Replit experience in isolation
Hostinger Hosting your monitoring dashboards, task boards and benchmark results Starting at a few euros/month (November 2026, check hostinger.com) Publishing and sharing the results of your own swarms

If you want to understand which model to choose as a worker agent, our guide to the best LLMs for AI agents details the latency/cost/reasoning trade-offs, and our comparison of the best autonomous AI agents covers orchestration frameworks.


The experiment's numbers — what Replit actually measured

Direct answer: Replit ran agents on optimizing open source libraries, with a protocol more rigorous than the average agent benchmark.

The setup, detailed in the primary source (Throwing Headcount at the Problem):

  • 14 open source libraries, 4 of which are detailed: NumPy (13 workloads), SQLite (12), SQLGlot (4), and Git (7).
  • 4 configurations: 1, 8, 16, and 32 agents.
  • 6 models: Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.2 Astra, GPT-6 Astra, GPT-6.1 Sol, and GPT-6 Luna.
  • Resources: 8 vCPU, 16 GiB RAM, 2 hours per agent.
  • Network disabled, post-execution audit to verify that the gains are real and not cheating (feature reduction, weakened tests).

Each agent runs in an isolated Linux microVM via Agent Habitat, Replit's swarm infrastructure. This matters: without isolation, the swarms step on each other and the results are unusable.

The headline result: 3.7x for a solo Opus 5.5 agent, 18.9x for the 32-agent swarm. But the most interesting detail lies elsewhere. On NumPy's searchsorted workload, the Opus swarm discovered it could batch the search 256 keys at a time to stay within the CPU cache — 8.7x to 13.1x faster with identical output. A solo agent wouldn't make this kind of discovery in 2 hours: you need one worker exploring it while another profiles the hot path while a third writes the validation benchmark.

This is exactly the pattern described in our article on Claude Opus 4.8 and Dynamic Workflows: the value of recent models no longer comes from raw reasoning, but from their ability to coordinate in complex harnesses.


Topology beats the model — the central finding

Direct answer: the best solo agent doesn't make the best swarms. The communication architecture determines the gain, not the choice of model.

GPT-6.2 Astra was "the strongest solo agent we tested," according to Replit. On NumPy, it beat Opus 5.5 solo by a factor of more than 3. And yet, its swarms degraded as they grew. Meanwhile, the Opus and Sonnet swarms beat their solo runs every single time, with a median of 1.30x additional gain at 16 and 32 agents.

The difference doesn't come from the model. It comes from how the agents communicate. The analysis by aiinsiders.net of coordination patterns is illuminating:

Configuration Messages to the shared board Direct messages to the coordinator
Opus 5.5 swarm (winner) 82% of messages ~1.4 per worker
GPT-6 Astra swarm a minority ~22 per worker
GPT-6.1 Sol swarm a minority ~20 per worker

The winning swarms operate like a team of senior developers: each one picks up a task from the board, works on it, publishes their result, and the coordinator only steps in to arbitrate. One thread per workload, no private side conversations.

The losing swarms operate like a team with no process: every worker asks the coordinator what to do, reports back to them, asks them questions. Replit's wording is brutal: "whose inbox grew with every agent added." And the numbers confirm it — when you double from 16 to 32 agents, the Sol coordinator's inbox goes from 356 to 631 messages on SQLGlot, and GPT-6 Astra's from 346 to 615 on NumPy. The scores, meanwhile, remain unchanged. The coordinator has become the bottleneck: you paid for twice as many agents for zero additional gain.

This is an architecture lesson, not a model lesson. And it lines up with what we observed in our coverage of Gemini 3.5 Flash on agentic benchmarks: in agentic tasks, coordination latency often weighs more heavily than inference latency.


Why the shared board works — information theory applied to teams

Direct answer: a shared board transforms communication from O(n²) to O(n), and eliminates the single point of failure that is the coordinator.

With a central coordinator that receives and routes all messages, the number of exchanges grows quadratically with the number of agents. At 32 agents, the coordinator processes hundreds of messages per workload — it becomes the bottleneck, and its context saturates with details it doesn't need to know in order to arbitrate.

With a shared board, each agent reads what interests it, claims a task, and publishes its result. The coordinator only steps in for occasional arbitration. Information flows without passing through a hub.

It's no coincidence that this topology resembles what works in human teams. Agile methodologies abandoned the route-everything project manager twenty years ago in favor of shared Kanban boards for the same reason: the cost of centralized coordination grows faster than the value it produces.

Academic research is beginning to formalize this phenomenon. The preprint Evolving Infra (MIT, Berkeley, Georgia Tech) shows that you can cut the latency of agent systems by rethinking infrastructure rather than models — same logic: architecture is the lever. And Google's Teamwork, which proves the Courtade-Kumar conjecture on agent swarms, points in the same direction: information theory applied to multi-agent communication precisely predicts the topologies that scale.

Replit provides the empirical validation. Theory said topology matters. November 2026 data shows by how much: between the best and worst architecture, with identical model and budget, the gap is measured in factors.


Codebase shape matters as much as architecture

Direct answer: NumPy lends itself to parallelism, Git resists swarms. The structure of the work determines the ceiling on the gain.

The 18.9x result is not a library fluke. NumPy offers 13 independent workloads: isolated functions, measurable hot paths, local optimizations that don't conflict with each other. A swarm can slice up the work cleanly, each worker taking a workload without touching the others' code.

Git is the opposite: 7 workloads across 15 files. Changes overlap, merges conflict, and even the best-architected swarms struggle to beat the solo run. When the work isn't parallelizable, adding agents only adds coordination overhead.

It's a lesson many teams will learn the hard way. Multi-agent isn't a universal accelerator — it's an accelerator for decomposable problems. Performance engineering, code migration, test generation, security audits: all of these share NumPy's property, independent units of work. Deep refactoring of a monolith, API design, debugging cross-cutting bugs: they share Git's property.

Before launching a swarm, ask yourself: are my tasks NumPy workloads or Git workloads? If you can't slice up the work by hand, a swarm won't slice it up for you.


The limitations and criticisms — what Replit doesn't say

Direct answer: the results are self-reported, with no independent reproduction, and several methodological details are missing.

It has to be said clearly: everything above comes from Replit, which sells Replit Missions, the product that makes it possible to deploy these swarms. The conflict of interest is structural. The Agent Times reports the announcement with the official X link but takes care to set it against the negative results in the literature (CooperBench, MAST). Explainx.ai goes further and lists what is not being said:

  • What are the exact 13 NumPy tasks? Without the list, it's impossible to know whether the workloads were chosen for their parallelizability.
  • How was the speedup aggregated? An "up to 18.9x" masks the dispersion — the 18.9x may be a peak on a single workload, not a median.
  • What is the cost per swarm size? 32 Opus 5.5 agents for 2 hours costs money. The gain/cost ratio at 32 agents is not published.
  • Do the results hold on other libraries? The 10 libraries that aren't detailed are not documented.

Explainx also flags a crucial point: this result corresponds to a domain where the agents improve their own harness. More parallel research = more gains, but at higher cost. It's a favorable case, not a general one.

Finally, the product context: Replit also announced that swarms built an application monitoring platform (DataCat) in 2 days with a $3,000 budget, as part of Replit Missions, with Mission Agreements that define success criteria, budgets, and human approvals. Once again, the primary source = the product vendor. Treat it as a vendor benchmark, not as an independent study.

My position: I consider the results plausible — the shared board topology is consistent with the theory and with what we observe in practice — but I'll wait for an independent reproduction before citing 18.9x in a deck. The qualitative pattern (topology > model) is already actionable. The exact number, no.


How to apply this to your own swarms

Direct answer: three concrete changes, in order of impact.

1. Replace the router coordinator with a task board. A shared markdown file, a lightweight database, or a dedicated tool — the medium doesn't matter. One thread per workload, each agent claims and publishes. The coordinator only arbitrates conflicts. If your coordinator receives more than ~5 direct messages per worker, your topology is already broken.

2. Isolate the agents. Without microVMs or per-agent containers, your swarms will step on each other, and you'll never know which gain comes from what. Isolation isn't optional — it's the prerequisite for measurability.

3. Measure the coordinator's inbox. That's your health metric. If it grows linearly with the number of agents, you've built a bottleneck, not a swarm. Replit found theirs by comparing 16 and 32 agents: identical score, doubled inbox. You can run the same test.

As for the choice of working model, Replit's Opus/Sonnet swarms suggest that Anthropic models handle coordination discipline better — but with 6 models tested and results that vary by topology, a word of caution. Our Claude vs ChatGPT comparison and our guide to the best LLMs for coding will help you choose based on your workload. And if you want to test locally without depending on cloud APIs, our guide on open source AI agents with Ollama covers the essentials — even though, let's be honest, local models don't yet reach the level required for this kind of performance engineering.


❌ Common Mistakes

Mistake 1: Choosing the model before the architecture

What goes wrong: most teams spend weeks benchmarking models, then paste their best model into a coordinator-router topology. The result: the best solo agent becomes a mediocre swarm, exactly like GPT-6.2 Astra at Replit.
The solution: decide on the topology first (shared board, isolation, workload splitting), then benchmark the models within that topology. Solo ranking is not a predictor of swarm ranking.

Mistake 2: Believing more agents = more gains

What goes wrong: doubling from 16 to 32 agents without changing the topology means paying twice as much for the same result. Worse: with routed coordination, the coordinator's inbox explodes (356 → 631 messages at Sol) and the system regresses.
The solution: always test two swarm sizes before scaling. If the gains don't follow, the problem is the topology, not the size.

Mistake 3: Applying multi-agent to non-parallelizable problems

What goes wrong: launching a swarm on a highly dependent refactoring task (the Git case from the experiment) and being surprised that 32 agents don't beat 1 agent.
The solution: assess how splittable the work is before launching. Independent workloads? Go ahead. Intertwined files? A well-prompted solo agent will do better, for less money.

Mistake 4: Quoting vendor numbers without qualifying them

What goes wrong: repeating "18.9x" in a presentation without mentioning that it's self-reported, without independent reproduction, and that the "up to" masks the variance.
The solution: always cite the source and the status. "Self-reported by Replit, not reproduced" is a five-word phrase that protects you from a credibility disaster.


❓ Frequently Asked Questions

Is the 18.9x independently verified?

No. All the figures come from Replit, which sells the product in question. The published methodology is serious (network disabled, post-execution audit, isolated microVMs), but no independent reproduction exists to date. The qualitative pattern — topology determines the gain — is consistent with the literature and theory. As for the exact figure, wait for a reproduction.

Why do GPT-6.2 Astra swarms degrade even though it's the best solo agent?

Because its workers communicate massively through the coordinator (~20-22 direct messages per worker, versus ~1.4 for Opus). At 32 agents, the coordinator's inbox explodes and becomes the bottleneck. Communication behavior is a property of the model or the harness, not of the model's raw intelligence.

Does it work on any codebase?

No. NumPy (13 independent workloads) lends itself well to parallelism; Git (7 workloads across 15 files) resists swarms, which struggle to beat the solo agent. Decomposability of the work is a prerequisite. If you can't break the work down by hand, the swarm won't do it for you.

What is the real cost of a 32-agent swarm?

Replit doesn't publish it — that's one of the main criticisms. 32 Opus 5.5 agents running for 2 hours represent a significant API budget. The gain/cost ratio at 32 agents vs 8 agents is unknown — and that's probably where the real economic question lies.

Should we abandon the coordinator-router pattern?

Not entirely, but it needs to be bounded. A coordinator that arbitrates conflicts and validates results remains useful. A coordinator that routes all information is an anti-pattern beyond 8 agents. Replit's rule of thumb: winning swarms send 82% of messages to the board, not to the coordinator.


✅ Conclusion

The lesson from Replit isn't "32 agents make NumPy 18.9x faster" — it's "your swarm's architecture determines the gain before the model is even chosen." The best solo agent on the market degrades in a team if you wire it poorly; a lesser agent soars if you give it a shared board and decoupled workloads. Start with the topology, measure your coordinator's inbox, and wait for independent replication before citing the numbers. To go further on choosing the models that make up your swarms, check out our guide to the best LLMs for AI agents.