AdaptEvolve: Adaptive Evolutionary Systems

Updated 5 July 2026

AdaptEvolve systems integrate evolutionary search with adaptive mechanisms that modify models, code, or parameters in response to dynamic environments.
They employ a structured separation between fast runtime operations and slower adaptive evolution loops to maintain coherent behavior.
Empirical evaluations show these systems reduce computational cost while retaining near-optimal performance through context-sensitive model selection.

AdaptEvolve denotes a class of systems that combine evolutionary search with explicit adaptation mechanisms, so that search policies, goals, code, models, or controller parameters can change in response to shifting environments rather than remaining fixed at design time. In the narrowest sense, the name refers to the framework “AdaptEvolve: Improving Efficiency of Evolutionary AI Agents through Adaptive Model Selection,” which inserts uncertainty-aware multi-LLM routing into an evolutionary sequential refinement loop (Ray et al., 12 Feb 2026). In a broader sense, recent arXiv work uses the same label descriptively for architectures that pair variation–selection–inheritance with online operator control, self-evolving software agents, adaptive auto-harnesses, cross-domain model evolution, and phenotype-first inheritance schemes (Robol et al., 29 Apr 2026, Liu et al., 1 Jun 2026, Wang et al., 4 Jan 2025, Le, 1 Feb 2026). Taken together, these works suggest an emerging pattern in which evolution supplies long-horizon structural change, while adaptation supplies fast, context-sensitive reconfiguration.

1. Scope of the term

The literature uses “AdaptEvolve” in several non-identical but related ways. One usage is nominal: a specific multi-LLM routing method for evolutionary refinement (Ray et al., 12 Feb 2026). Another is architectural: a blueprint for systems that evolve artifacts while adapting the mechanisms that generate, select, or deploy them.

Setting	What adapts or evolves	Representative paper
Multi-LLM evolutionary refinement	Model choice during mutation	(Ray et al., 12 Feb 2026)
Self-evolving software agents	Goals, reasoning structures, executable code	(Robol et al., 29 Apr 2026)
Open-ended agent deployment	Harness construction, branch routing, human steering	(Liu et al., 1 Jun 2026)
Adaptive LLM evolution	Exploration intensity, island allocation, tactic generation	(Cemri et al., 23 Feb 2026)
Knowledge-adaptive evolutionary operators	Selection, crossover, mutation parameterization	(Wang et al., 4 Jan 2025)
Cross-domain spatiotemporal evolution	Common container growth and coupling decisions	(Liu et al., 21 May 2025)

This heterogeneity is substantive rather than terminological. In some papers, the adaptation target is computational budget or model capacity; in others it is the agent’s own goals, its memory structure, its operator schedule, or its inherited phenotype. A plausible synthesis is that AdaptEvolve refers not to one canonical algorithm but to a family of systems in which adaptation acts on the evolutionary process itself, or on artifacts produced by that process, under non-stationary conditions.

2. Core architectural pattern

A recurring design principle is separation between a runtime or deployment loop and a slower adaptation/evolution loop. In “Self-Evolving Software Agents,” a classical BDI cycle—belief update, desire generation, intention selection, plan execution—remains active at runtime, while an independently operating Automated Evolution Module monitors experience, detects unmet needs, elicits new requirements, revises design, synthesizes code, and validates new behaviors before inheritance (Robol et al., 29 Apr 2026). The purpose of this separation is to preserve behavioral coherence while allowing long-term structural change.

An analogous decomposition appears in “Adaptive Auto-Harness.” There, tasks arrive as an open-ended stream, and the framework formalizes performance shortfall as the sum of an evolution loss and an adaptation loss:

$E_{x_t}[\mathrm{Regret}(\phi, x_t)] = L_{\mathrm{evo}}(\Phi) + L_{\mathrm{adapt}}(\phi).$

The first term captures what the evolver class cannot construct from history; the second captures the loss from committing to one dense harness before seeing the next task (Liu et al., 1 Jun 2026). This decomposition makes explicit that adaptation is not identical to evolution: one can build a stronger harness yet still route poorly at solve time, or route well over a weak harness.

A third recurring component is an explicit memory or inheritance channel. In self-evolving BDI agents, successful behaviors are retained and reused while ineffective ones are discarded (Robol et al., 29 Apr 2026). In OKAEM, a growing knowledge store of historical populations and fitness evaluations informs online operator updates (Wang et al., 4 Jan 2025). In phenotype-first models such as the Phenopoiesis Algorithm, learned compositional recipes are transmitted epigenetically across generations in parallel with slower genetic change (Le, 1 Feb 2026). Across these settings, “adaptation” is therefore not merely online tuning; it is online tuning with persistence, selection, and reuse.

The paper explicitly titled “AdaptEvolve” defines the method as “Adaptive LLM Selection for Multi-LLM Evolutionary Refinement within an evolutionary sequential refinement framework” (Ray et al., 12 Feb 2026). It is built on an OpenEvolve-style loop in which an agent maintains a population of code candidates, mutates them with an LLM, evaluates them against test cases, and updates the archive. The central intervention is at the mutation step: instead of always using one model, the system first probes a small model and uses intrinsic uncertainty to decide whether that model is sufficient or whether to escalate to a larger one.

Formally, for a candidate $x_i$ , mutation is routed by a classifier $\Phi$ over confidence features $C(x_i)$ :

$x_i' = \begin{cases} \mathcal{M}_S(x_i) & \text{if } \Phi(C(x_i)) = 1 \ \mathcal{M}_L(x_i) & \text{otherwise}. \end{cases}$

The small model is Qwen3-4B and the large model is Qwen3-32B. Confidence is derived from token log-probabilities exposed by the small model. The per-token statistic is

$c_i = - \frac{1}{k} \sum_{j=1}^{k} \log P_i(j),$

and sequence-level features are then aggregated as Mean Confidence, Lowest Group Confidence, Tail Confidence, and Bottom-K% Group Confidence (Ray et al., 12 Feb 2026).

Routing is learned in two stages. An initial Decision Tree with Gini impurity and max depth 5 is trained on a warm-up set of $N=50$ samples. During online operation it is replaced by a Hoeffding Adaptive Tree, which updates incrementally under distribution drift as the evolutionary population changes. The decision logic is explicitly cost-aware: one Qwen3-32B call is normalized to cost 1.0, and one Qwen3-4B call to 0.125. Efficiency is defined as

$\mathrm{Eff} = \frac{\mathrm{Accuracy}}{\mathrm{Compute\ Cost}}.$

Empirically, the framework reports that confidence-driven selection reduces total inference cost by an average of 37.9% across benchmarks while retaining 97.5% of the upper-bound accuracy of static large-model baselines (Ray et al., 12 Feb 2026). On LiveCodeBench, the Adaptive Hoeffding Tree achieves a 42:58 small-to-large routing ratio, cost 2.08, accuracy 73.6, and efficiency 35.4; on MBPP it routes 85:15, with cost 0.69, accuracy 91.3, and efficiency 132.3 (Ray et al., 12 Feb 2026). Against a FrugalGPT-style cascade on LiveCodeBench, AdaptEvolve attains similar accuracy but lower cost: the cascade uses cost 2.81 for accuracy 73.8 and efficiency 26.3, whereas the adaptive tree uses cost 2.08 for accuracy 73.6 and efficiency 35.4 (Ray et al., 12 Feb 2026).

The framework’s limitations are integral to its definition. It requires token-level log-probabilities, so it does not directly apply to closed APIs that do not expose them. It assumes concurrent access to both a small and a large model, and it provides no formal regret or risk guarantees. Its calibration also depends on a small warm-up set, although the paper reports that the online HAT is more robust than a static tree under drift (Ray et al., 12 Feb 2026).

4. Software-agent and open-ended deployment interpretations

In software-agent research, AdaptEvolve is closely associated with the move from runtime adaptation to genuine software evolution. “Self-Evolving Software Agents” defines such agents as systems that can autonomously revise their own goals, internal reasoning structures, and executable capabilities over time on the basis of accumulated experience (Robol et al., 29 Apr 2026). The proposed BDI–LLM architecture augments a classical BDI loop with an Automated Evolution Module that performs requirement elicitation, design revision, and code synthesis when the agent encounters situations it cannot interpret or exploit with its current knowledge, goals, or actions. The prototype is evaluated in a dynamic multi-agent environment inspired by Deliveroo.js, starting from only a textual description of the environment and a minimal API surface. The reported outcome is qualitative but central: the agent can autonomously discover operational goals and generate executable behaviors from minimal prior knowledge, while limitations emerge in behavioral inheritance and robustness as environment complexity increases (Robol et al., 29 Apr 2026).

In deployment-oriented agent systems, the same idea is pushed toward sustained adaptation under open-ended streams. “Adaptive Auto-Harness” argues that repeatedly updating a single dense harness is brittle because histories grow unboundedly, task regimes are heterogeneous, and problem distributions drift over time (Liu et al., 1 Jun 2026). Its system addresses this with a stateful multi-agent evolver, a harness tree with solve-time routing, and human-steering hooks when the needed signal is absent from history. The evolver is explicitly role-specialized—Analyst, Researchers, Builder, Verifier—and learns only from temporally revealed feedback. On PolyBench, the full system reports 97.9% Coverage, 80.9% Accuracy, and +330% Return; on CTF-Dojo it reaches 50.2% Pass; on FutureX, the best reported variant is the Multi-agent system at 49.5% Pass (Liu et al., 1 Jun 2026). The conceptual importance is the distinction between building capability and selecting among capabilities at solve time.

A related agentic realization is “Evolutionary Ensemble of Agents,” which maintains two co-evolving populations: functional code solvers and agent guidance states (Yu et al., 9 May 2026). Agents are evaluated through a synchronous race under identical context, and empirical Elo ratings are updated from marginal solver gains. In ICON, this system discovers a rescale-then-interpolate positional mechanism that enables reliable example-count generalization. The best EvE runs achieve search-time errors of 0.0957 and 0.0966, and under standardized retraining their top designs reach $\overline{e}_{10\text{k steps}} = 0.041$ and 0.045 (Yu et al., 9 May 2026). Static ablations—including a frozen “best-evolved” agent—underperform, which the paper interprets as evidence that stage-dependent adaptation is necessary to avoid phase mismatch (Yu et al., 9 May 2026).

5. Adaptive operator control, data selection, and representation evolution

A major branch of AdaptEvolve research concerns the adaptation of search operators themselves. “AdaEvolve” reformulates LLM-driven program evolution as a hierarchical adaptive zeroth-order optimization problem (Cemri et al., 23 Feb 2026). Its central statistic is an accumulated improvement signal,

$G_t(k) = \rho G_{t-1}(k) + (1-\rho)[\Delta_t(k)]^2,$

which drives three levels of control: Local Adaptation for exploration intensity within an island, Global Adaptation for discounted UCB routing across islands, and Meta-Guidance for generating new tactics when progress stalls. Across 185 tasks, AdaEvolve reports consistent gains over static baselines. On Frontier-CS, mean score rises to 61.33 versus 50.75 for OpenEvolve, 47.79 for ShinkaEvolve, 43.04 for GEPA, and 20.64 for single-call GPT-5; on circle packing, the best reported run reaches 2.636 (Cemri et al., 23 Feb 2026). Ablations show that all three adaptive levels contribute, with Meta-Guidance producing the largest drop when removed on the highlighted tasks (Cemri et al., 23 Feb 2026).

A data-centric interpretation appears in “EvoSelect,” which inserts a selection stage into iterative synthetic-data evolution for targeted LLM adaptation (Li et al., 28 Apr 2026). Candidate samples are embedded by proxy gradients, aligned to the validation distribution with entropic optimal transport, and diversified by a quadratic redundancy penalty. Selection weights are updated on the simplex by an exponentiated rule using standardized OT dual potentials and diversity gradients. Empirically, EvoSelect consistently outperforms all-data training and other selection baselines. In the strong-generator setting with a 3B base model, average accuracy rises to approximately 0.758–0.760 on science tasks versus 0.750 for the base model, approximately 0.556–0.559 on commonsense/logical tasks versus 0.534, and approximately 0.557–0.562 on biomedical tasks versus 0.543 (Li et al., 28 Apr 2026). The paper emphasizes that the method is the only one in the comparison that consistently improves over the base model across tasks and ratios (Li et al., 28 Apr 2026).

OKAEM generalizes the same principle to evolutionary operators. It uses attention to model interactions among individuals, fitness values, and genes, thereby parameterizing selection, crossover, and mutation directly from accumulated optimization knowledge (Wang et al., 4 Jan 2025). The system supports pre-training on source-task histories and self-tuning on target-task elites. Its core self-tuning loss is

$x_i$ 0

where $x_i$ 1 denotes the top- $x_i$ 2 elite population and $x_i$ 3 the offspring generated by the learned operators. The paper reports that OKAEM exploits prior knowledge for significant gains across knowledge-transfer settings, remains competitive in self-tuning-only mode, outperforms state-of-the-art black-box baselines in a vision-LLM tuning case, and improves as its knowledge base grows (Wang et al., 4 Jan 2025).

In cross-domain spatiotemporal learning, “SynEVO” uses the language of adaptation and evolution to describe model growth through a curriculum-ordered sequence of domains (Liu et al., 21 May 2025). Its Elastic Common Container accumulates common structure, the Task-Independent Extractor preserves domain personality, and an Adaptive Dynamic Coupler decides whether a new domain should be fused into the common container. The paper reports that SynEVO improves generalization capacity by up to 42% under cross-domain scenarios, with average improvements of about 25.0% on NYC, 2.6% on CHI, 5.8% on SIP, and 18.3% on SD relative to baselines except CMuST, and an average improvement of approximately 35.6% over vanilla GraphWaveNet across the four datasets (Liu et al., 21 May 2025).

6. Broader analogues, persistent limitations, and research directions

The same structural idea appears outside software adaptation. In phenotype-first evolutionary computation, the Phenopoiesis Algorithm introduces a dual inheritance channel in which organisms inherit not only genes but also successful phenotypic recipes stored in an epigenome (Le, 1 Feb 2026). On changing 10×10 shape tasks, PHENO adapts 3.4 times faster than the gene-centric baseline: under fast switching, generations to 80% fitness are 8.3 ± 3.1 for PHENO, 14.7 ± 5.2 for BALDWIN, and 28.4 ± 8.9 for GENE (Le, 1 Feb 2026). In robotics, real-world co-evolution of morphology and control on DyRET shows terrain-conditional specialization, with transfer distances lowest for same-hardness pairs—0.053 for A versus C and 0.048 for B versus D (Nygaard et al., 2020). A distinct zero-shot adaptation variant combines GA-evolved neural controllers with online Hebbian plasticity gated by live fitness; on the e-puck T-maze, the GA+Hebbian controller achieves 100% success across base, 2-obstacle, and 4-obstacle environments, whereas the GA-only controller succeeds only in the base environment (Hammami et al., 5 Aug 2025). These are not identical algorithms, but they instantiate the same coupling of inherited structure with rapid context-sensitive change.

Several misconceptions recur in this literature. One is that adaptation can replace evolution. The evidence is mixed: within-lifetime learning alone is weaker than cross-generational pattern inheritance in Phenopoiesis (Le, 1 Feb 2026), and fixed initial or frozen final agents underperform continuously adapting ensembles in EvE (Yu et al., 9 May 2026). Another is that a single high-capacity system can remain optimal throughout a non-stationary search. AdaptEvolve (Ray et al., 12 Feb 2026), AdaEvolve (Cemri et al., 23 Feb 2026), and Adaptive Auto-Harness (Liu et al., 1 Jun 2026) all reject this assumption, albeit at different levels: model routing, compute allocation, and harness specialization.

The main technical limitations are likewise shared. Stability under increasing complexity remains unresolved in self-evolving BDI agents, which explicitly call for reinforcement mechanisms, memory consolidation, and stronger selection strategies (Robol et al., 29 Apr 2026). EvoSelect identifies dependence on proxy-gradient fidelity and the scaling cost of dense OT and similarity matrices (Li et al., 28 Apr 2026). OKAEM notes high-dimensional complexity and suggests reducing $x_i$ 4 and $x_i$ 5 below $x_i$ 6 to control the $x_i$ 7 regime (Wang et al., 4 Jan 2025). Adaptive Auto-Harness reports routing brittleness and emphasizes clearer branch documentation, fallback thresholds, and replay audits (Liu et al., 1 Jun 2026). The named AdaptEvolve framework itself is constrained by logprob availability and lacks formal guarantees (Ray et al., 12 Feb 2026).

Current research directions therefore converge on a small set of unresolved questions: how to stabilize inheritance, how to route or schedule adaptation under drift without excessive cost, how to preserve diversity without losing coherence, and how to represent transferable structure so that adaptation remains fast while evolution remains cumulative. A plausible implication is that future AdaptEvolve systems will increasingly combine three elements already present in separate papers: explicit lifecycle separation between runtime reasoning and structural revision, memory mechanisms that decide what is inherited and what is forgotten, and adaptive controllers that treat compute, search intensity, or model capacity as first-class evolutionary variables.