Stateful Multi-Agent Evolutionary Search

• Stateful multi-agent evolutionary search is a family of frameworks where agents use persistent memory to inform search decisions over dynamic landscapes.
• It leverages diverse memory substrates like archives, research trees, and execution traces to condition mutation, crossover, and selection strategies.
• The approach integrates evolutionary operators with adaptive search control, enhancing agent coordination and optimizing performance in complex tasks.

Stateful multi-agent evolutionary search denotes a family of optimization and discovery frameworks in which multiple agents search over candidates, policies, programs, or interaction graphs while carrying forward persistent state across rounds, generations, or tasks. The persistent state may take the form of explicit memories, archives, research trees, branch histories, execution traces, long-term reflections, or learned agent states, and it is used to condition selection, mutation, crossover, orchestration, or scheduling. Across the literature, the search space ranges from NK landscapes and continuous policy parameters to multi-agent system configurations, code artifacts, and collaboration graphs; the common feature is that search is not memoryless, because later decisions depend on accumulated evidence about earlier trajectories, failures, and successes (Bahceci et al., 2023).

1. Formal scope and problem formulations

One line of work formalizes stateful search directly as a competitive multi-agent process on a dynamic landscape. In competitive multi-agent search, the search space is a bit-string space $X=\{0,1\}^n$ with NK-model fitness

$$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$

where each local contribution $f_i:\{0,1\}^{K+1}\to[0,1]$ is chosen uniformly at random, and indices wrap mod $N$. The landscape is dynamic because whenever any agent visits $\mathbf x$, the fitness of $\mathbf x$ and its Hamming-neighbors within radius $R$ is multiplied by a flocking intensity $\alpha>1$ or $\alpha<1$, modeling value inflation or saturation. Agents compete for cumulative reward over $T$ discrete time steps by visiting points in $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$0, and their interaction is mediated both by knowledge of other agents’ searches and by landscape changes induced by those searches (Bahceci et al., 2023).

A second formalization treats the search object not as a point in a fitness landscape but as an entire multi-agent system configuration. EvoMAS defines a configuration

$$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$1

where $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$2 is a directed acyclic graph over agent nodes, each agent $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$3 has backbone model, system prompt, and tool set, and designated input and output agents specify execution flow. For a task $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$4, execution under $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$5 yields an output $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$6 and an execution trace $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$7, while a judge function returns a scalar reward such as

$$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$8

The objective for each incoming task is to find $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$9, while leveraging persistent pools and memories from earlier tasks (Hu et al., 6 Feb 2026).

A third formulation arises in model-based stochastic search for multi-agent control. Here the black-box optimization problem is

$f_i:\{0,1\}^{K+1}\to[0,1]$0

with a parametric sampling distribution $f_i:\{0,1\}^{K+1}\to[0,1]$1 over policy parameters and expected return

$f_i:\{0,1\}^{K+1}\to[0,1]$2

In multi-agent settings, each of $f_i:\{0,1\}^{K+1}\to[0,1]$3 agents may share the same global parameter vector $f_i:\{0,1\}^{K+1}\to[0,1]$4, while the return $f_i:\{0,1\}^{K+1}\to[0,1]$5 depends on the entire stateful trajectory $f_i:\{0,1\}^{K+1}\to[0,1]$6 generated by the simulator. This framing is stateful because the optimizer treats $f_i:\{0,1\}^{K+1}\to[0,1]$7 as a black-box function, but the simulator internally propagates all stateful interactions, stochastic transitions, and agent specialization (Fan et al., 2018).

A broader, process-level formalization appears in AEvo, which views agentic evolution as an interactive environment whose state is the accumulated evolution context. At round $f_i:\{0,1\}^{K+1}\to[0,1]$8, the context is $f_i:\{0,1\}^{K+1}\to[0,1]$9, and the environment state can be written as $N$0. A meta-agent observes a summary $N$1, samples a meta-action $N$2, and edits the search mechanism itself via $N$3. This shifts the locus of optimization from individual candidates to the procedure or agent context that governs future candidate generation (Zhang et al., 13 May 2026).

2. Persistent state, memory, and archival structures

Statefulness is implemented through several distinct but related memory substrates. In competitive multi-agent search, each agent maintains public memory $N$4, the set of all points published by any agent up to time $N$5, and private memory $N$6, the points remembered only by that agent. If agent $N$7 has visited points $N$8 with fitnesses $N$9, its total knowledge is

$\mathbf x$0

At each step, the agent examines the best fitness in each memory, converts those values to binary low/high states using threshold $\mathbf x$1, and then conditions action choice and storage decisions on those states. This is a minimal but explicit form of memory-dependent policy control (Bahceci et al., 2023).

EvoMAS maintains two persistent structures at task index $\mathbf x$2: a pool of candidates $\mathbf x$3 and an experience memory $\mathbf x$4 storing tuples $\mathbf x$5. Each best tuple $\mathbf x$6 is appended by

$\mathbf x$7

For new queries, the system retrieves sketches or summaries $\mathbf x$8 by task similarity, and these retrieved patterns condition mutation and crossover so that previously learned structural motifs can be reused (Hu et al., 6 Feb 2026).

LoongFlow uses a hybrid evolutionary memory. Its solution memory stores lineage and summaries for every solution, including code, unique solution identifier, parent identifier, generate plan, retrospective summary, and performance metrics. After evaluation, the system samples a summary $\mathbf x$9 and updates the global memory by set union,

$\mathbf x$0

Alongside this, each island maintains a MAP-Elites archive $\mathbf x$1 over a behavior space $\mathbf x$2, with feature mapping $\mathbf x$3, so that each cell stores the best solution found in that region (Wan et al., 30 Dec 2025).

OR-Agent makes the memory structure explicitly tree-shaped. Each LeadAgent conducts a research round represented by a rooted, directed tree $\mathbf x$4 of hypothesis nodes, where each node

$\mathbf x$5

The tree is stateful because every node retains idea text, code, experimental summary, and child-expansion status; nodes with no improvement after $\mathbf x$6 attempts are marked terminal, while other leaves remain eligible for expansion and backtracking. OR-Agent complements this with a persistent SolutionDatabase and compressed long-term reflection states updated by exponential moving averages (Liu et al., 14 Feb 2026).

Other frameworks instantiate statefulness in operational rather than symbolic form. SwarmResearch stores global context in an orchestrator as tuples $\mathbf x$7 for each branch, while each Search Agent is confined to its git worktree and, for Optimizers, its forked chat history (Virk et al., 2 Jul 2026). The stateful inference-time search framework for unit-test generation represents persistent state as

$\mathbf x$8

thereby preserving earlier edge cases, mutation scores, coverage values, exception signals, and rewards (Lalan et al., 8 Oct 2025). HEAS adopts a global context $\mathbf x$9, a dictionary-like shared state updated by deterministic layered streams, so that cross-scale couplings become explicit and auditable (Zhang et al., 21 Aug 2025).

A plausible implication is that “state” is not a single design pattern but a spectrum ranging from low-dimensional policy context to fully persistent process memory. The literature uses all of these forms, often simultaneously.

3. Evolutionary operators and search control

The evolutionary mechanisms differ by search space but share the feature that operators are conditioned on persistent evidence. In the CMAS framework, each agent uses a stochastic strategy $R$0 to select one of four actions—Exploit(public), Exploit(private), Explore(public), Explore(private)—after inspecting the public and private memories. “Exploit” flips one bit until improvement, whereas “Explore” flips a random $R$1 of bits until improvement. If the new point is better than the previous point, a second strategy $R$2 decides whether to store it in public or private memory. Both $R$3 and $R$4 are jointly encoded in CPPNs evolved with NEAT (Bahceci et al., 2023).

The associated NEAT setup is concrete. A population of $R$5 CPPNs encodes $R$6 and $R$7 jointly; each CPPN has four inputs and two outputs, starts with only input and output nodes and minimal connectivity, and evolves through link addition, node addition, weight perturbation or redraw, link deletion, crossover within species, fitness sharing, survival threshold $R$8, and elitist preservation of the species champion. Each candidate is evaluated as “agent 0” against seven fixed-strategy opponents, with one evolution fitness defined as the average of that agent’s visited-point fitness over $R$9 steps, averaged over $\alpha>1$0 random starts (Bahceci et al., 2023).

EvoMAS defines two generative kernels. Mutation proposes a locally edited offspring $\alpha>1$1 from parent $\alpha>1$2, execution trace, and memory, while constraining each mutation to exactly one component type: prompts, model identifiers, tools, or topology. Crossover recombines two parents’ agent-level specifications under the requirement that the offspring inherits the full communication graph of one parent. Parent selection can be tournament-based or fitness-proportional, with a probability proportional to $\alpha>1$3, and both mutation and crossover are guided by execution traces and retrieved summaries from memory (Hu et al., 6 Feb 2026).

LoongFlow replaces blind random mutation with a Plan-Execute-Summarize paradigm. Given parent $\alpha>1$4 and memory $\alpha>1$5, it samples a plan

$\alpha>1$6

then a new solution

$\alpha>1$7

then a summary

$\alpha>1$8

followed by memory update $\alpha>1$9. Parent selection inside each island uses entropy-regularized Boltzmann selection,

$\alpha<1$0

with temperature adapted by archive entropy (Wan et al., 30 Dec 2025).

The stateful inference-time search framework adopts adversarial mutation and elite preservation. The Adversary generates $\alpha<1$1 mutants $\alpha<1$2, and the mutation score

$\alpha<1$3

measures how many mutants are killed by the candidate edge cases. Evolutionary preservation keeps the top-$\alpha<1$4 edge cases across generations: $\alpha<1$5 The Critic’s reward combines exception triggering, coverage, and mutation robustness through

$\alpha<1$6

This makes mutation testing an adversarial search operator rather than a post hoc evaluation tool (Lalan et al., 8 Oct 2025).

AgentRevive applies state-aware evolution over agent graphs rather than candidate artifacts. Each agent occupies one of three Markov states $\alpha<1$7: Active, Standby, or Terminated. The transition policy $\alpha<1$8 conditions transitions on prior state, hallucination risk, message gain, and latent state. Hallucination risk is computed as a KL divergence between an agent’s message distribution and the average over active agents, and state-aware edge optimization subsequently prunes edges by survival masks derived from repeated inference passes (Zhang et al., 17 May 2026).

This suggests that in stateful multi-agent evolutionary search, “variation” can target not only candidate solutions but also prompts, topologies, branches, archives, memory summaries, or agent participation states.

4. Multi-agent organization and orchestration patterns

The literature exhibits several recurring orchestration patterns. One is fixed-population interaction in a shared environment. In CMAS, $\alpha<1$9 agents operate on a dynamic NK landscape; one evolvable agent competes against seven fixed agents in homogeneous or heterogeneous environments (Bahceci et al., 2023). In the UAV swarm setting, each of $T$0 agents shares the same global parameter vector $T$1, but differing local observations naturally induce specialization such as leader-follower, flanking, and sacrifices even under shared parameters (Fan et al., 2018).

A second pattern is explicit role decomposition. The unit-test generation framework uses four cooperating agents—Actor, Adversary, Critic, and Executor—under a non-Markovian Controller. Each stage comprises proposal, execution, adversarial mutation, scalar reward assignment, and controller-mediated state update (Lalan et al., 8 Oct 2025). LoongFlow similarly decomposes the loop into Planner, Executor, and Summarizer modules, nested within a multi-island topology (Wan et al., 30 Dec 2025). OR-Agent separates ORAgent, SolutionDatabase, multiple LeadAgents, IdeaAgent, CodeAgent, and ExperimentAgent, thereby assigning distinct responsibilities for ideation, code synthesis, experimentation, and archival management (Liu et al., 14 Feb 2026).

A third pattern is orchestrator-subagent search over code branches. SwarmResearch introduces a Shepherd Agent that maintains global context and steers a population of Search Agents, each operating with local context in a separate git branch. Explorer Agents attempt one new high-level idea with fresh context, whereas Optimizer Agents inherit the parent’s conversation history and perform up to $T$2 small tweak-and-test iterations. Parent selection is modeled by a softmax-style distribution over observed branch fitnesses, and the mix between Explorers and Optimizers is regulated by a schedule $T$3 (Virk et al., 2 Jul 2026).

A fourth pattern is meta-editing of the search mechanism itself. AEvo’s meta-agent does not directly propose the next candidate; rather, it edits the procedure or agent context that will govern the next segment of inner-loop evolution. Phase A performs meta-editing of code, prompts, skill files, or budgets, while Phase B executes the edited mechanism for a bounded number of inner rounds under a protected evaluator. This architecture unifies procedure-based evolution and agent-based evolution under a common harness (Zhang et al., 13 May 2026).

HEAS emphasizes yet another organizational principle: separation of mechanism from orchestration. Models are represented as hierarchies of lightweight processes or streams arranged in deterministic layers that read and write a shared context. The same model can then be used for forward simulation, optimization, or tournament comparison, with uniform per-step and episode metrics and explicit persistence of seeds, logbooks, and hall-of-fame archives (Zhang et al., 21 Aug 2025).

A common misconception is that multi-agent evolutionary search necessarily means a conventional genetic algorithm over a flat population. The surveyed systems include flat populations, tree-structured research, island models, branch-based harnesses, controller-driven role systems, and meta-editing frameworks. The shared property is persistent multi-agent coordination under evolutionary or evolution-like update rules, not a single canonical topology.

5. Empirical domains, behaviors, and reported outcomes

The empirical range is unusually broad. Competitive multi-agent search was studied on NK landscapes with $T$4, $T$5, flocking intensity decaying linearly from $T$6 over $T$7 visits at each point, and flocking radius $T$8. Specialized strategies evolved one environment at a time outperform all hand-coded baselines by $T$9 on average with $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$00, while general strategies across $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$01 environments fall only $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$02 below specialized strategies and still exceed the hand-coded “best overall” with $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$03. Heterogeneous single-environment evolution yields nearly identical general performance at $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$04 the cost. A 2-ply real-time tree search is reported as less effective when resource-matched to CMAS methods and suffers from dynamic landscape mis-prediction (Bahceci et al., 2023).

That work also reports a distinctive behavioral phenomenon: in sparse regimes with $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$05, successful strategies show a strong preference for short exploit hops in private memory, characterized as “wave-riding” of the boosting front. A spherical visualization that maps Hamming-distance shells onto latitude rings and fitness to elevation or brightness reveals the agent staying on the advancing boosted frontier while leaving sunk points behind (Bahceci et al., 2023).

In multi-agent UAV swarm combat, model-based stochastic search and evolution strategies are applied to two tasks. The cooperative Base-Attack scenario contains 50 fixed-wing attackers versus 20 quadcopter defenders, with observation dimension $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$06, action outputs specifying target relative coordinates, and reward

$$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$07

After $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$08 ES/CEM iterations over $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$09 runs, median Base-Attack performance is reported as 38 kills and 12 base-hits for ES $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$10, versus 24 kills and 5 base-hits for CEM. Each iteration, comprising $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$11 samples and $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$12 s episodes at $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$13 s step, runs in parallel on $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$14 threads in approximately $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$15 minutes; full training takes approximately $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$16 days (Fan et al., 2018).

For LLM-based multi-agent system generation, EvoMAS is evaluated on BBEH, WorkBench, and SWE-Bench. It improves task performance by $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$17 points over EvoAgent, including $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$18 points on BBEH, $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$19 points on WorkBench, and $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$20 points on SWE-Bench-Verified. It achieves near-perfect execution rates of $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$21, compared with code-generation baselines MAS-GPT at $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$22, and continues to gain up to $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$23 points with increased test-time compute while single-agent and fixed MAS baselines plateau (Hu et al., 6 Feb 2026).

LoongFlow is evaluated on the AlphaEvolve benchmark and Kaggle-style tasks. Reported outcomes include 14 gold medals across vision, NLP, and tabular tasks; 0.9027 versus 0.8962 on Autocorrelation II relative to the AlphaEvolve baseline; and a Circle Packing result in which the framework reaches a target $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$24 in 258 evaluations versus 783 for OpenEvolve, described as a 60% improvement in efficiency (Wan et al., 30 Dec 2025).

SwarmResearch is tested on 15 open-ended optimization tasks spanning mathematics, systems, and heuristics. It discovers better-performing or comparable solutions on 13/15 tasks relative to state-of-the-art LLM-guided evolution and multi-agent techniques, matches or exceeds EvoX on 14/15 tasks, and matches or exceeds CORAL on 12/15 tasks under the same compute budget. The same study reports median per-attempt code changes of 48 lines of code for SwarmResearch, versus 15 for CORAL and 29 for EvoX (Virk et al., 2 Jul 2026).

The stateful inference-time search framework is evaluated on HumanEval and TestGenEvalMini using Llama-70B, GPT-o4-mini, and Gemma-2-27B. On HumanEval, the cold-start rule-based Actor alone solves approximately 62% of problems at first iteration, and the full evolutionary search matches or slightly exceeds few-shot baselines at approximately 90–92% coverage. On TestGenEvalMini, the method delivers a 4–7 percentage-point absolute lift in line and function coverage over the best few-shot baselines, including an example of line coverage from approximately 25% to 29.8% with Llama-70B. Branch coverage gains are described as model-dependent, and the method incurs higher compute, approximately 3.6 PFLOPs per iteration on TestGenEvalMini (Lalan et al., 8 Oct 2025).

AEvo reports a 26 relative improvement over the strongest baseline on standard benchmarks. On Terminal-Bench, AEvo$$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$25 improves from 44.3 to 53.8; on ARC-AGI-2, it improves from 31.8 to 47.0. On three open-ended optimization tasks, AEvo$$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$26 achieves best or tied-best scores on all three and reaches 1138 cycles on the performance-engineering task in 100 rounds, with continued improvement to 1121 in 200 rounds (Zhang et al., 13 May 2026).

AgentRevive reports up to 33.7% token savings and 6.9% performance gain on MMLU with Llama3-8B, with only $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$27 s inference overhead, while framing these gains as the result of state-aware scheduling that preserves “Standby” agents instead of hard-pruning them immediately (Zhang et al., 17 May 2026).

6. Interpretive themes, misconceptions, and open problems

Several themes recur across these systems. First, persistent state is repeatedly used to combat local myopia. In CMAS, public and private memory allow policies to exploit both shared and private information while reacting to dynamic landscape changes (Bahceci et al., 2023). In EvoMAS, execution traces and experience memory make mutation and crossover feedback-conditioned rather than blind (Hu et al., 6 Feb 2026). In AEvo, accumulated process-level evidence becomes actionable because the meta-agent edits the search mechanism itself (Zhang et al., 13 May 2026).

Second, diversity preservation is a central design concern, but different frameworks realize it differently. MAP-Elites archives and multi-island migration preserve behavioral niches in LoongFlow (Wan et al., 30 Dec 2025). Elite archives preserve top edge cases in inference-time search (Lalan et al., 8 Oct 2025). Solution databases, tree backtracking, and temperature-controlled sampling preserve multiple research trajectories in OR-Agent (Liu et al., 14 Feb 2026). Git branches in SwarmResearch preserve competing high-level approaches that would otherwise be overwritten in a single conversational context (Virk et al., 2 Jul 2026). This suggests that diversity preservation is not merely a selection heuristic; it is often encoded in the system’s memory substrate.

Third, the literature distinguishes between hard pruning and reversible attenuation. AgentRevive explicitly criticizes aggressive graph evolution that permanently removes agents based on transient failure, proposing instead Markov states Active, Standby, and Terminated so that “zombie” agents can recover in later rounds (Zhang et al., 17 May 2026). A related, though not identical, concern appears in SwarmResearch’s argument that single long-running agents tend to converge on one high-level approach and then make only low-level edits (Virk et al., 2 Jul 2026).

Fourth, several frameworks replace direct low-level mutation with structured reflection. LoongFlow’s Planner and Summarizer, OR-Agent’s verbal gradient and semantic momentum, and AEvo’s meta-editing of prompts, skills, and procedures all move evolutionary search toward explicitly reasoned intervention rather than undirected perturbation (Wan et al., 30 Dec 2025). A plausible implication is that current stateful systems increasingly blur the line between evolutionary search, tree search, and research workflow management.

The principal limitations reported in the literature are likewise varied. Stateful systems can incur substantially higher inference-time or orchestration cost, as illustrated by the TestGenEvalMini compute figures in stateful inference-time search and the approximately $$F(\mathbf x)\;=\;\frac1N\sum_{i=1}^N f_i\bigl(x_i,x_{i+1},\dots,x_{i+K}\bigr),$$28 per-round cost noted for AEvo on standard benchmarks (Lalan et al., 8 Oct 2025). Some methods remain prompt-reliant or near-greedy at the orchestration level, as stated for SwarmResearch’s Shepherd Agent (Virk et al., 2 Jul 2026). Others acknowledge the absence of domain-independent merge criteria, stable long-horizon policies, or broader support for multi-file and dependency-heavy environments (Lalan et al., 8 Oct 2025).

Taken together, these works define stateful multi-agent evolutionary search as a broad research area rather than a single algorithm. It encompasses dynamic landscape search, policy optimization in simulators, evolutionary generation of multi-agent systems, branch-based code search, research-tree exploration, archive-based directed evolution, and resilient graph scheduling. The unifying principle is that evolutionary progress is mediated by persistent multi-agent state, and that this state is treated not as auxiliary logging but as a first-class control variable for future search.