AdaEvolve: Adaptive Evolution Frameworks

• AdaEvolve is an adaptive framework characterized by dynamic resource allocation and hierarchical control to optimize evolutionary search and neural network adaptation.
• It integrates LLMs and DNNs to adjust exploration versus exploitation in real time, enabling improved performance in tasks like program synthesis and edge inference.
• The system leverages real-time progress signals and meta-guidance to overcome stagnation, achieving robust performance gains across diverse benchmarks.

AdaEvolve refers to a family of adaptive frameworks designed to enhance the efficiency and performance of evolutionary search and continuous neural network adaptation. These systems are characterized by their dynamic resource allocation, hierarchical adaptation strategies, and integration with powerful generative models, such as LLMs or deep neural networks (DNNs). AdaEvolve frameworks are applicable across domains including automated program synthesis, combinatorial optimization, algorithm search, code generation, and edge-supported DNN evolution for mobile inference.

1. Core Concepts and Motivations

The AdaEvolve class of systems emerges in response to the limitations of static search schedules in evolutionary algorithms—particularly when using LLMs or DNNs as semantic mutation operators. Traditional evolutionary methods with fixed exploration–exploitation parameters are ineffective under non-stationary fitness landscapes, where improvement rates vary over time and across candidate populations. Consequently, substantial computational resources are often expended on stagnating subpopulations, while promising regions are undersampled. AdaEvolve frameworks unify all adaptation decisions via signals derived directly from observed optimization progress, rather than relying on pre-specified, hand-tuned control policies (Cemri et al., 23 Feb 2026).

Separately, AdaEvo extends adaptive evolution to the context of resource-limited edge computing for on-device inference. By continuously retraining and compressing DNNs at the edge in response to observed data drift—while optimizing Quality of Experience (QoE) for end users—the system maintains high inference quality even under distribution shift (Wang et al., 2023).

2. Hierarchical Adaptive Evolutionary Framework

AdaEvolve introduces a strictly hierarchical adaptive control architecture with three levels (Cemri et al., 23 Feb 2026):

Level 1 — Local Adaptation: Modulates the exploration intensity within each subpopulation (“island”) based on an accumulated improvement signal $G_t^{(k)}$. The exploration rate $I_t^{(k)}$ adapts according to recent progress,

$$I_t^{(k)} = I_{\min} + (I_{\max} - I_{\min}) \frac{1}{1 + \sqrt{G_{t-1}^{(k)} + \epsilon}}$$

where $I_{\min}$ and $I_{\max}$ bound the allowable diversification.

Level 2 — Global Resource Adaptation: Treats each island as a multi-armed bandit arm. Bandit-based scheduling allocates the next LLM inference to the island that most likely yields the highest normalized global improvement, balancing exploration, exploitation, and resource fairness.

Level 3 — Meta-Guidance: Upon global stagnation (all $G^{(j)} \leq \tau_M$), the system prompts the LLM for high-level solution “tactics.” This includes analyzing bottlenecks in current best solutions and proposing concrete new strategies, which are then injected into subsequent generations.

This tripartite control loop unifies decision-making, from prompt construction and parent selection to population migration and qualitative strategic shifts, all driven by a single progress signal per island.

3. Formal Problem Definition and Objective Functions

The general AdaEvolve optimization setting considers a discrete, black-box fitness function $\mathcal{F} : \mathcal{P} \to \mathbb{R}$, where the goal is to maximize $\mathcal{F}$ over candidate programs with a total inference call budget $T$. The evolution is organized over $K$ islands, each maintaining an archive $I_t^{(k)}$0. At each iteration, a candidate solution is sampled, mutated via the LLM, evaluated, and archived. Progress per island is quantified by the accumulated improvement $I_t^{(k)}$1:

$I_t^{(k)}$2

where $I_t^{(k)}$3.

For edge DNN evolution, AdaEvo defines per-user QoE over deployment cycles:

$I_t^{(k)}$4

weighted by urgency $I_t^{(k)}$5 and subject to resource constraints on edge servers:

$I_t^{(k)}$6

where $I_t^{(k)}$7, $I_t^{(k)}$8 denote per-task memory and compute demands.

4. System Architecture and Algorithms

The general AdaEvolve workflow is governed by the following sequence (Cemri et al., 23 Feb 2026):

1. Initialization: For each island, initialize an archive, fitness tracker, improvement signals, and bandit statistics.
2. Island Selection: Use upper confidence bound (UCB) bandit selection to choose the next island for mutation, incorporating decayed statistics of normalized reward and pull counts.
3. Parent Sampling and Prompt Construction: Modulate between exploration (random parent + diverse inspirations) and exploitation (fitness-weighted parent + local refinements) via the local intensity signal.
4. LLM Mutation and Evaluation: Generate offspring via LLM prompt, evaluate fitness, update archives and progress statistics.
5. Meta-Guidance Injection: Upon broad stagnation, prompt the LLM for new strategic solution tactics, deploying them in future generations.
6. Dynamic Topology: Spawn new islands upon deep stagnation or periodic migration of best solutions to neighboring islands.

For AdaEvo (edge DNN), drift detection and adaptive retraining are handled via:

• Unsupervised Drift Detection: Uses composite detection confidence ($I_t^{(k)}$9) and sliding window statistics to estimate accuracy drop without labels.
• Drift-Type-Aware Frame Sampling: Adopts fixed, ramped, or feature-difference-based sampling dictated by drift type (sudden, incremental, gradual), controlling retraining data size and diversity.
• Resource-Constrained Scheduling: Employs Bucketing and Knapsack-style DP to schedule and allocate retraining jobs across limited edge resources, optimizing both throughput and user fairness.

5. Empirical Performance and Quantitative Results

AdaEvolve demonstrates robust quantitative superiority over static and non-adaptive evolutionary baselines (Cemri et al., 23 Feb 2026):

• On 185 open-ended problems (mathematical optimization, systems, program synthesis), AdaEvolve attains or surpasses human/AlphaEvolve bests in 4/6 combinatorial tasks and leads all 7 ADRS benchmarks (e.g., improving transactions scheduling makespan from 4329 to 4348).
• In algorithm design (Frontier-CS, GPT-5), mean and median scores are 61.3/75.2, compared to OpenEvolve’s 50.8/56.4.
• Cross-domain ARC-AGI-2 accuracy reaches 49% vs. OpenEvolve's 42%; overall, AdaEvolve yields consistent Pareto improvements.

AdaEvo edge scheduling improves mean [email protected]:0.95 up to +22.9% over original, +13.6% over domain-adapt baseline, and +14.9% over fixed downsample for single-end cases. Multi-end benchmarks show 63% lower evolution latency and up to 32% better average QoE (Wang et al., 2023).

Resource allocation logic and adaptation incur negligible computational overhead compared to the LLM/DNN inference passes.

6. Limitations and Future Directions

Documented limitations of AdaEvolve include:

• Reliance on clean, informative improvement signals; if the fitness evaluator is highly noisy, the adaptation may be unstable—a larger decay coefficient or signal smoothing may be needed.
• Meta-guidance demands strong LLM introspective and analytic skills; in very large or poorly structured domains, this brittleness can limit escape from local optima.
• Fixed adaptation thresholds ($$I_t^{(k)} = I_{\min} + (I_{\max} - I_{\min}) \frac{1}{1 + \sqrt{G_{t-1}^{(k)} + \epsilon}}$$0, $$I_t^{(k)} = I_{\min} + (I_{\max} - I_{\min}) \frac{1}{1 + \sqrt{G_{t-1}^{(k)} + \epsilon}}$$1) and hyperparameters may require tuning for unfamiliar domains. Automatic meta-optimization of these parameters is a proposed direction.
• Edge DNN versions (AdaEvo) require accurate estimation of confidence and resource profiles and may not generalize outside labeled object detection or similar modalities.

Planned extensions include integration with multi-objective or constraint-augmented black-box optimizations, local differentiation heuristics where possible, adaptation to closed-weight models via surrogate uncertainty signals, and scaling to broader distributed parallelization frameworks.

7. Relationship to Other Adaptive and Evolutionary Systems

AdaEvolve shares conceptual ancestry with the OpenEvolve, GEPA, and ShinkaEvolve frameworks but stands apart through its uniform, signal-driven control loop spanning all adaptation levels and problem domains (Cemri et al., 23 Feb 2026). Unlike static-resource LLM mutation designs, AdaEvolve exploits observed improvement rates for dynamic balancing of exploration, exploitation, and migration. In edge DNN contexts, AdaEvo uniquely combines unsupervised drift detection with hybrid frame selection and resource-aware scheduling to maintain high real-world inference performance (Wang et al., 2023). A plausible implication is that the AdaEvolve design paradigm—progress-driven hierarchical adaptation—provides an extensible blueprint for the next generation of evolutionary, agentic, and adaptive search systems.