SwarmEvolve: How Latent-Space Agent Swarms Cut Scientific Program Search Time from 60 Minutes to 8

Most multi-agent AI systems communicate the same way humans do: one agent writes something, the next reads it, thinks, and writes back. It works, but it carries a hidden cost. Every time an agent converts its internal reasoning into text, it loses information — the probability distributions, the uncertainty, the nuance that lived in the model's hidden states. The next agent then has to reconstruct all of that from prose.

A new paper from Jiang and Karniadakis at Brown University calls this the "decoding tax," and their framework, SwarmEvolve, is designed to eliminate it entirely.

The Problem with Text-Based Agent Pipelines

LLM-guided evolutionary search — where AI agents iteratively propose, evaluate, and refine programs or mathematical constructions — has become a productive area of research. Frameworks like OpenEvolve and AlphaEvolve have demonstrated that language models can discover novel scientific algorithms when given the right scaffolding.

The bottleneck is throughput. In a standard setup, an agent generates a chain-of-thought in natural language, that text is tokenized and fed to the next agent, which generates more text, and so on. For tasks where the fitness function is machine-checkable (does this code produce the right output? does this packing arrangement beat the previous record?), the prose is largely overhead. The agents are writing for each other, not for humans.

SwarmEvolve asks: what if agents skipped the text entirely?

Reasoning in Latent Space

The core mechanism of SwarmEvolve is straightforward in concept, though technically precise in execution. Instead of sampling tokens, each agent feeds its last hidden state $\mathbf{h}t$ back as the next input embedding $\mathbf{e}{t+1}$ through a learned alignment matrix $\mathbf{W}_a$. The agent performs 40 of these latent reasoning steps — thinking without writing — before its internal state is passed along.

This is not a new idea in isolation. Latent-space reasoning has been explored in various forms. What SwarmEvolve adds is a structured multi-agent architecture built around it.

Each round of evolution deploys 450 agents organized into 10 specialized swarms. The swarms have different roles: some refine existing programs, some hybridize two parent programs, some explore fresh directions. Within each swarm, a novelty filter computes the mean hidden state of each agent and uses greedy farthest-point selection in cosine distance to keep the most distinct reasoning trajectories, discarding agents whose internal states are too similar to others.

The retained agents then pass their KV caches — the key-value attention matrices that encode their reasoning context — to a summarizer agent. The summarizer attends to all of these concatenated caches simultaneously, synthesizing a new program proposal that integrates the diverse perspectives of the swarm without any of them having to write a word.

What the Numbers Show

The authors evaluated SwarmEvolve on 21 problems spanning mathematical discovery and scientific computing: packing problems, geometry, differential equations, and similar domains where a deterministic evaluator can score candidate solutions.

The headline result: SwarmEvolve reaches the 60-minute performance scores of text-based baselines (OpenEvolve, ShinkaEvolve, CodeEvolve) in a median of 3 to 8 minutes. It evaluates 5 to 13 times more candidate programs per hour than those frameworks.

More interesting than the speed is the quality ceiling. Using Qwen3-8B — a relatively small model — SwarmEvolve outperformed baselines running Qwen3-32B-FP8. In three cases, it improved upon constructions previously discovered by AlphaEvolve using frontier-scale models. The authors attribute this to the higher throughput enabling broader exploration of the search space, rather than any architectural superiority of the underlying model.

One important caveat: these are paper-reported results. The SwarmEvolve repository currently lists its core implementation as "coming soon," and independent reproduction has not yet been established as of this writing.

The Engineering Trade-offs

The efficiency gains come with real constraints that practitioners should understand before getting excited about deploying something like this.

Model homogeneity is required. Because agents share KV caches, they must use the same model architecture, tokenizer, and attention implementation. You cannot mix a small local model with a frontier API call mid-swarm. This rules out the common pattern of routing difficult subproblems to more capable models.

Infrastructure is non-trivial. Standard LLM serving stacks like vLLM with prefix caching are not optimized for the kind of cross-agent KV cache sharing SwarmEvolve requires. Keeping hundreds of agent caches warm and addressable simultaneously is a memory-intensive operation that requires purpose-built infrastructure.

Debugging becomes harder. When something goes wrong in a text-based pipeline, you have conversation logs. In a latent-space pipeline, you have numerical performance metrics and hidden state vectors. Engineers working with SwarmEvolve would need to build new instrumentation — periodic state sampling, rendering tools — to understand what the agents are actually doing.

Consensus collapse is a risk. If agents fork from a shared KV cache and their novelty filter fails to maintain diversity, the swarm can converge on a single reasoning trajectory. At that point, you have 450 agents effectively doing the same thing, which defeats the purpose of the architecture.

Where This Fits

The practical decision about whether latent swarms make sense depends almost entirely on the nature of the task. The FCMO-AI Newsletter's analysis puts it well: adopt latent handoffs when the fitness function is machine-checkable and the agents are homogeneous. Retain prose handoffs when you need human-readable artifacts, heterogeneous model ensembles, or transparency for debugging.

For scientific computing, kernel optimization, and automated algorithm discovery, SwarmEvolve's approach is well-suited. For general-purpose agentic workflows — customer support, code review, document drafting — the trade-offs are harder to justify.

The broader point, as one practitioner noted on Dev.to, is that the "prose bus" between agents is often a convenience for developers, not a requirement for the agents themselves. When the task is machine-graded and the agents are homogeneous, that convenience has a measurable cost.

What Comes Next

SwarmEvolve is a research prototype, not a production system. The immediate questions are whether the results hold up under independent replication, whether the infrastructure requirements can be reduced, and whether the novelty filter is robust enough to prevent consensus collapse at scale.

The deeper question it raises is more interesting: as AI systems increasingly use each other as components, how much of the text-based interface between them is genuinely necessary? The answer is probably "less than we currently assume" — but the engineering work to replace it safely is substantial.

The paper and GitHub repository are available for those who want to dig into the implementation details.