SwarmEvolve: 450 latent agents pass KV caches instead of writing text — a frozen Qwen3-8B reaches baselines' 60-min scores in 3–8 min

SwarmEvolve swaps text chain-of-thought for latent-space reasoning: 450 agents pass KV caches to one another, and on a frozen Qwen3-8B the paper reports reaching the 60-minute scores of three open evolutionary-search baselines in a median of 3–8 minutes. The preprint from Brown University's applied-math group also claims its 8B model improves on three constructions that AlphaEvolve originally found with frontier Gemini models.

What shipped

SwarmEvolve (arXiv:2611.08483, by Qile Jiang and George Em Karniadakis) is an LLM-guided evolutionary program search built on a simple premise: agents stop writing their reasoning down. Instead of decoding text chain-of-thought each round, hundreds of agents reason in the model's continuous embedding space and pass KV caches to each other.

Each round runs 450 latent agents in 10 swarms of 45. The swarms have different jobs — refinement, hybridization, exploration, and fresh starts. Inside a swarm, each agent reasons for a fixed 40 latent steps, feeding its last-layer hidden state back as the next input embedding through a ridge-regression alignment matrix, decoding no text. Each step appends one position to the KV cache.

A novelty filter keeps the most distinct ideas. Each agent is represented by its mean hidden state, and selection keeps the 30 of 45 whose trajectories are farthest apart in cosine distance. A summarizer agent then reads the combined KV caches of the kept agents — plus the parent programs — and decodes one new program. Because agents in a swarm studied different parents, the summarizer recombines ideas from different programs in latent space — built-in crossover, in the authors' terms.

A separate parameter-tuning agent proposes up to eight one-number edits per round.

The mechanism is training-free and builds on LatentMAS, a prior framework where agents reason via latent thoughts and exchange a shared KV-cache working memory. SwarmEvolve adapts it to evolutionary search, adding an archive-driven loop, focused swarms, a diversity filter, and crossover through the summarizer.

Why it matters

The headline result is throughput. On 21 problems spanning mathematical discovery and scientific computing, the paper reports SwarmEvolve evaluates 5–13× more programs per hour than the three open baselines (OpenEvolve, ShinkaEvolve, CodeEvolve) — a mean of 734 programs versus 158, 99, and 81 respectively on Qwen3-8B. It reaches the baselines' 60-minute scores in a median of 3–8 minutes.

It reports the highest average score at all three model sizes tested (Qwen3 8B, 14B, 32B-FP8) and claims at 8B it outscores all three baselines running 32B-FP8.

The deeper point inverts the frontier-model scaling story. The paper claims a frozen, open-weights 8B model, given ~450 cheap agents per round that think in a shared latent space instead of writing text, re-derives constructions AlphaEvolve originally found with frontier Gemini models and improves on three: packing 26 circles in a square (reaching a sum of radii of 2.635983, which the paper calls best known) and the bounds for the second and third autocorrelation inequalities.

Most of the speedup is a wall-clock engineering effect, and the paper says so. Because agents neither decode nor encode text between steps, a round of 40 latent steps costs roughly 4 seconds versus ~32 seconds for a 256-token text round. That is cheaper parallelism for discovery, not evidence that latent reasoning produces better individual ideas.

The paper's own ablation shows the two are close: 40-step latent scored 0.804 average versus 0.796 for 40-token text and 0.767 for 256-token text. On one problem ("Heilbronn in a triangle"), text reasoning beat latent reasoning (0.796 vs 0.558).

Caveats

Treat every number above as vendor-reported. The code is not yet released — the GitHub repo says "The SwarmEvolve code will be released soon." Nothing has been independently reproduced.

A few specific limits worth knowing:

• No controlled AlphaEvolve comparison. The "beats AlphaEvolve" claims rest on AlphaEvolve's published reference constructions, not a controlled run of AlphaEvolve itself. The baselines each improved on only one problem versus SwarmEvolve's three.
• The "Google Research" label is wrong. The AI Weekly summary headlines this as "Google Research's SwarmEvolve," but the paper and GitHub identify the authors' affiliation as Brown University's Division of Applied Mathematics. The Google connection is only via the AlphaEvolve baseline.
• No ablation isolates the mechanism. No experiment separates the novelty filter or KV-cache crossover as the cause of the gains; the text-vs-latent ablation mostly shows a wall-clock speed effect.
• Hardware constraints. All agents and the summarizer must share one LLM (KV caches can't cross models), and KV-cache memory grows with agents, reasoning steps, and layers — so it needs a large GPU.
• The "158–402" range is misleading. The AI Weekly summary's "734 vs 158–402" mixes the baseline throughput (158/99/81) with the 402 figure from the paper's 256-token-text ablation, not a baseline.

The honest takeaway: this is a promising, cheap way to parallelize program search, and the wall-clock speedup is real. Whether latent reasoning beats text reasoning on quality remains open; the paper's own data leave it ambiguous.

Sources

• SwarmEvolve paper (abstract): https://arxiv.org/abs/2611.08483v1
• SwarmEvolve paper (full text): https://arxiv.org/html/2611.08483v1
• Code repo: https://github.com/Qile-J/SwarmEvolve
• LatentMAS paper: https://arxiv.org/abs/2511.20639
• AI Weekly summary: https://aiweekly.co/alerts/google-researchs-swarmevolve-runs-450-latent-reasoning-agents-beats-alphaevolve
• alphaXiv overview: https://www.alphaxiv.org/abs/2611.08483