Illustrative image: a swarm of bees — hundreds of simple agents, one coordinated result. SwarmEvolve works the same way, with AI agents instead of bees. Image: Denis Carrascosa, via Wikimedia Commons, public domain.
📌 KEY HIGHLIGHTS
- 450 agents, zero words: SwarmEvolve runs 10 swarms of 45 latent agents each round. They reason in the model's hidden numerical space and share information by passing key-value caches — never by writing text.
- Minutes, not hours: on 21 maths and scientific-computing problems, it reached the best scores rival frameworks need 60 minutes for in a median of just 3 to 8 minutes, testing 5 to 13 times more candidate programs per hour.
- Small model, big results: using the open-weight Qwen3 8B model, it improved on solutions AlphaEvolve first found with much larger frontier models.
- Real maths, not demos: it matched the best-known packing of 26 circles in a square and improved bounds on autocorrelation inequalities — open problems, not toy benchmarks.
- One catch: every agent must currently share the same underlying model, so the swarm cannot yet mix different models.
SwarmEvolve explained: the swarm that never speaks
Evolutionary search is one of the oldest ideas in computing: generate lots of candidate solutions, keep the best, mutate them, and repeat. In the last two years, researchers have supercharged it with large language models — the AI writes candidate programs, the programs are tested, and the winners are bred into the next round. Google DeepMind's AlphaEvolve used this recipe to find new solutions in mathematics and chip design.
The bottleneck is the talking. In a normal setup, every agent has to write out its reasoning as text — a long chain of thought — before the next agent can use it. That text is slow to generate, expensive to re-read, and it floods the model's context window. SwarmEvolve, published as an arXiv preprint on 5 November 2026 by Qile Jiang and George Em Karniadakis of Brown University's Division of Applied Mathematics, removes the talking entirely.
Its agents do not write sentences. They think in latent space — the model's internal numerical representation — and hand each other their key-value caches, the working memory of a transformer, directly. A partial forward pass replaces a full generation, so hundreds of cheap agents can run in parallel on a single GPU. The paper's name is literal: the swarm evolves solutions, and it does so silently.
How the latent swarm works
Each round launches 10 swarms with 45 agents each — 450 agents in total — and every swarm is given a different angle on the problem: one works on the mathematical formulation, another hunts for bugs, another explores ideas drawn from the literature. Each agent takes 40 latent reasoning steps without producing a single human-readable token.
Two mechanisms keep the swarm honest. A novelty filter measures the distances between the agents' hidden state vectors and discards the 15 most similar lines of thought, keeping the 30 most distinct perspectives — so the swarm explores genuinely different ideas instead of 450 copies of the same one. Then a summariser agent reads the combined key-value caches of the surviving agents and synthesises a single refined program candidate. Ideas cross over in latent space, without ever being translated into words.
| Step | Traditional evolutionary search | SwarmEvolve |
|---|---|---|
| Agent reasoning | Long written chain of thought, every round | 40 latent steps, no text at all |
| Agents share | Text messages and evaluation logs | Key-value caches, passed directly |
| Diversity | Repeated generation, hoping for variety | Novelty filter on hidden-state distances |
| Combining ideas | Text prompts that merge the best candidates | Summariser reads combined caches |
| Scale per round | A handful of agents | 450 agents in 10 swarms, one GPU |
Illustrative image: a starling murmuration — coordination without a leader giving orders. Image: Walter Baxter, via Wikimedia Commons / geograph.org.uk, CC BY-SA 2.0.
The results: minutes, not hours
The team tested SwarmEvolve against three established frameworks — OpenEvolve, ShinkaEvolve and CodeEvolve — on 21 problems spanning packing geometry, mathematical analysis, combinatorics and scientific computing. Each framework got 60 minutes on the same hardware, using open-weight models from Alibaba's Qwen3 family (8B, 14B and 32B-FP8).
SwarmEvolve took the highest average score across the suite. It evaluated 5 to 13 times more candidate programs per hour than the baselines, and reached their 60-minute scores in a median of 3 to 8 minutes. Most strikingly, running the smallest model in the test — Qwen3 8B — it still beat the final scores of all three baselines even when those baselines were running the much larger Qwen3 32B-FP8. And on several problems it improved on the solutions AlphaEvolve first found using frontier proprietary models, including matching the best-known arrangement for packing 26 circles in a square and tightening bounds on autocorrelation inequalities.
The honest caveat is that these are the authors' own benchmarks on their own problem set, and the paper is a preprint — it has not yet been peer-reviewed. But the design of the test is fair on its face: same time budget, same hardware, same model family for everyone.
Why it matters for researchers in India and everywhere
The headline result is not just speed. It is cost. Until now, the best results in AI-guided discovery came from the biggest models, which meant the biggest budgets — frontier-model API bills or clusters of high-end GPUs. SwarmEvolve shows a small open-weight model, run on a single GPU, out-discovering systems built on far larger ones. That changes who can do this kind of research.
For Indian universities, labs and startups, the practical meaning is direct: evolutionary search for maths, chip design, scheduling and scientific computing no longer needs a frontier-model budget to be competitive. A research group with one good GPU and an open model can now run the same class of discovery loop that was, until this month, the preserve of the best-funded labs. It also matters for how AI agents work in general — the paper is evidence that agents do not have to talk in English to collaborate, and that the "prose bus" between agents is a design choice, not a law of nature.
The limits — what SwarmEvolve cannot do yet
The paper is candid about its main limitation: every latent agent and the summariser must currently share a single underlying language model, because key-value caches are only compatible within the same model. You cannot yet mix a small fast model with a large clever one in the same swarm. The authors suggest learned translations between model spaces and compressed latent messaging as future work, along with scaling across distributed hardware clusters.
There are two more limits worth stating plainly. First, the swarm's reasoning is unreadable by design — no text is ever produced, so there is no transcript to inspect when something goes wrong. Debugging means trusting the fitness score, not reading the reasoning. Second, the method only works where results can be checked automatically by running a program. It fits maths and scientific computing; it does not fit problems where the only judge is human taste — which is also why the best coding agent fully solved only 26.4% of real tasks in Alibaba's Co-Design Bench, where the work is messier than a checkable maths problem.
Should you care?
FAQs
What is SwarmEvolve?
SwarmEvolve is a research framework from Brown University that uses hundreds of small AI agents to discover better algorithms and mathematical solutions. The agents work in swarms, reason in the model's hidden numerical space without writing text, and share information by passing key-value caches. It was published on arXiv on 5 November 2026.
How does SwarmEvolve work without writing text?
Instead of generating sentences, each agent takes 40 latent reasoning steps — calculations inside the model that are never decoded into words. Agents pass their key-value caches (the transformer's working memory) directly to each other, and a summariser agent combines those caches into a refined program candidate. A novelty filter keeps only the most distinct ideas.
How fast is SwarmEvolve compared to AlphaEvolve?
SwarmEvolve is not a head-to-head race against AlphaEvolve, but it beat AlphaEvolve's published solutions on several problems while using the small open-weight Qwen3 8B model. Against three current frameworks (OpenEvolve, ShinkaEvolve, CodeEvolve), it reached their 60-minute scores in a median of 3 to 8 minutes and tested 5 to 13 times more programs per hour.
Can I use SwarmEvolve?
Not yet as a product. SwarmEvolve is a research paper, not downloadable software, and the authors have not announced a public code release. Anyone wanting to build on it starts from the arXiv preprint — and the core idea, latent-space agent communication, is one other teams can now test in their own systems.
Takeaway: The fastest way to make AI agents collaborate may be to stop making them talk. SwarmEvolve's silent swarm found better answers, faster, on cheaper hardware — and that is a result worth watching, whether or not the framework itself becomes a standard tool.
If you want the full detail, the paper itself is short and readable — start with the abstract on arXiv, then read our agentic AI explainer for how the agents inside systems like this actually work.
Comments
Post a Comment