SwarmEvolve: Latent Agent Swarms for Evolutionary Discovery and Optimization

Core Methodology§

SwarmEvolve introduces a latent-space multi-agent evolutionary framework for program search. Unlike traditional LLM-guided evolutionary methods that rely on textual chain-of-thought (CoT) and repeated decoding, SwarmEvolve operates directly in the latent space of the LLM. Each round, hundreds of low-cost agents (e.g., Qwen3 8B) are instantiated. Instead of generating text, each agent processes the problem and produces a sequence of hidden states. These hidden states are used to guide program mutations or generation, and communication between agents occurs via sharing of KV caches rather than text.

The framework comprises several key components:

• Latent Reasoning Swarms: Agents are grouped into swarms, each exploring a different angle of the problem. Within a swarm, agents share information by passing KV caches, allowing them to build on each other's latent representations without decoding to text. This drastically reduces computational cost and latency.
• Novelty Filter: To maintain diversity, a novelty filter selects the most distinct ideas by measuring pairwise distances between the hidden state vectors of agents. The filter keeps agents whose representations are sufficiently different from the population mean or from each other, ensuring exploration of diverse solution spaces.
• Latent Crossover: Crossover of ideas occurs naturally when a summarizer agent receives the combined KV caches of all swarm members. The summarizer integrates these caches to produce a new latent representation that blends the best features of the parents, effectively performing crossover in latent space without explicit textual recombination.
• Evolutionary Loop: The process iterates: mutate (via latent reasoning), evaluate (using a problem-specific scoring function), select (novelty filter and fitness-based selection), and crossover (via summarizer). The best programs are retained and refined over generations.

Implementation Details§

The implementation leverages the transformer's KV cache mechanism. Each agent is an instance of an LLM that processes a prompt and generates a KV cache. The KV cache for each layer is a tensor of shape $(2, \text{batch}, \text{num\_heads}, \text{seq\_len}, \text{head\_dim})$. When agents share information, their KV caches are concatenated along the sequence dimension, allowing subsequent agents to attend to the combined context. The summarizer agent processes the combined KV cache to produce a new cache that represents the merged idea.

Mathematically, let $\mathbf{K}_i, \mathbf{V}_i$ be the key and value caches of agent $i$. The combined cache is $\mathbf{K}_{\text{comb}} = [\mathbf{K}_1; \mathbf{K}_2; \dots; \mathbf{K}_n]$ and similarly for $\mathbf{V}$. The summarizer's output hidden state $\mathbf{h}_{\text{sum}}$ is computed as:

$$\mathbf{h}_{\text{sum}} = \text{LLM}(\mathbf{h}_{\text{input}}, \mathbf{K}_{\text{comb}}, \mathbf{V}_{\text{comb}})$$

where $\mathbf{h}_{\text{input}}$ is the summarizer's initial hidden state. This hidden state is then used to generate a new program or to update the population.

Novelty is measured using cosine distance between hidden state vectors: $d(\mathbf{h}_i, \mathbf{h}_j) = 1 - \frac{\mathbf{h}_i \cdot \mathbf{h}_j}{\|\mathbf{h}_i\| \|\mathbf{h}_j\|}$. Agents with distances below a threshold are pruned.

Below is a simplified PyTorch snippet illustrating the latent crossover via KV cache sharing:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

def get_kv_cache(model, input_ids):
    with torch.no_grad():
        outputs = model(input_ids, use_cache=True, return_dict=True)
    return outputs.past_key_values  # tuple of (key, value) per layer

def combine_kv_caches(kv_caches):
    # kv_caches: list of past_key_values from different agents
    combined = []
    for layer_idx in range(len(kv_caches[0])):
        keys = torch.cat([cache[layer_idx][0] for cache in kv_caches], dim=2)  # concat along seq_len
        values = torch.cat([cache[layer_idx][1] for cache in kv_caches], dim=2)
        combined.append((keys, values))
    return tuple(combined)

# Example usage:
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-8B")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-8B")

# Assume we have multiple agents with their input_ids (prompts)
agent_inputs = [tokenizer("Solve problem X", return_tensors="pt").input_ids for _ in range(5)]
kv_caches = [get_kv_cache(model, inp) for inp in agent_inputs]
combined_cache = combine_kv_caches(kv_caches)

# Summarizer agent processes combined cache
summarizer_input = tokenizer("Summarize these ideas", return_tensors="pt").input_ids
with torch.no_grad():
    summarizer_output = model(summarizer_input, past_key_values=combined_cache, use_cache=True)
new_hidden = summarizer_output.last_hidden_state  # use for next generation

Results and Implications§

SwarmEvolve was evaluated on 21 problems in mathematical discovery and scientific computing. It achieved the highest average score and reached best scores in a median of 3-8 minutes, compared to 60 minutes for state-of-the-art frameworks. Notably, with Qwen3 8B, it improved upon solutions originally found by AlphaEvolve with frontier LLMs. This demonstrates that latent-space agent swarms can offer a fast, low-cost alternative for program search, leveraging the efficiency of latent reasoning and KV cache sharing to enable massive parallel exploration without the overhead of textual generation.