💬 NLP

AdaEvolve: Adaptive LLM Driven Zeroth-Order Optimization

AdaEvolve is a hierarchical adaptive optimization framework that replaces static schedules with dynamic, LLM-driven mechanisms to modulate exploration, route resources, and generate novel tactics, thereby significantly outperforming existing baselines across diverse open-ended optimization problems.

Original authors: Mert Cemri, Shubham Agrawal, Akshat Gupta, Shu Liu, Audrey Cheng, Qiuyang Mang, Ashwin Naren, Lutfi Eren Erdogan, Koushik Sen, Matei Zaharia, Alex Dimakis, Ion Stoica

Published 2026-02-24

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Mert Cemri, Shubham Agrawal, Akshat Gupta, Shu Liu, Audrey Cheng, Qiuyang Mang, Ashwin Naren, Lutfi Eren Erdogan, Koushik Sen, Matei Zaharia, Alex Dimakis, Ion Stoica

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a very smart, but slightly stubborn, robot (a Large Language Model) how to solve a complex puzzle, like packing circles into a square or writing a new type of computer code.

In the past, we told the robot: "Here is the puzzle. Try 100 times. Every time, try a random change. If it gets better, keep it. If not, try again."

This is like giving a hiker a map and saying, "Walk in a straight line for 100 steps, then turn 90 degrees and walk 100 more steps, no matter what you see." It's rigid. If the hiker hits a wall, they keep walking into it. If they find a great path, they might stop exploring other possibilities too soon.

AdaEvolve is like giving that hiker a smart, adaptive guide who watches their progress in real-time and changes the strategy on the fly.

Here is how it works, broken down into three simple levels:

1. The "Pace" of the Search (Local Adaptation)

Imagine you are looking for a hidden treasure.

When you are close to a clue: You want to be very careful and look at every tiny detail. You don't want to wander off.
When you are stuck in a dead end: You need to stop looking at the same spot and start running in new, wild directions to find a new path.

AdaEvolve does this automatically. It watches how much the robot's solution is improving.

If the robot is making great progress, the system says, "Great job! Let's slow down and refine this specific idea." (Exploitation).
If the robot stops improving, the system says, "You're stuck! Stop looking at this spot and try something completely different!" (Exploration).
The Magic: It doesn't need a human to tell it when to switch. It senses the "vibe" of the progress itself.

2. The "Team Manager" (Global Adaptation)

Now, imagine you don't just have one hiker; you have a whole team of them, all searching different parts of the forest at the same time.

The Old Way: You give every hiker the exact same amount of food and water, regardless of whether they found a river or are stuck in a swamp.
The AdaEvolve Way: It acts like a smart manager. It watches the team.
- If Hiker A finds a great path, the manager sends more food and water to Hiker A to help them go further.
- If Hiker B is stuck in a swamp and hasn't moved in a while, the manager stops sending them supplies and sends those resources to Hiker A instead.
- It even creates new hikers (new search teams) if the whole group seems to be stuck, ensuring no one is wasting time on a dead end.

3. The "Coach" (Meta-Guidance)

Sometimes, no matter how much you run or how much food you give the team, they just can't solve the puzzle. They are using the wrong method. Maybe they are trying to climb a mountain when they should be swimming across a river.

This is where the Coach steps in.

When the system realizes everyone is stuck, it doesn't just tell the robot to "try harder." It asks the robot to step back and think about the strategy.
The Coach says: "Hey, we've been trying to arrange these circles by moving them one by one. That's not working. Let's try a completely new trick: what if we use a mathematical formula to slide them all at once?"
This changes the rules of the game to break the deadlock.

Why is this a big deal?

The paper tested this system on 185 different problems, from designing new computer algorithms to packing shapes perfectly.

The Result: AdaEvolve didn't just beat the old, rigid methods; it often beat the best solutions created by humans and even other advanced AI systems.
The Analogy: If the old methods were like a robot blindly following a script, AdaEvolve is like a chess grandmaster who knows when to attack, when to defend, when to sacrifice a piece, and when to change the entire game plan.

In short: AdaEvolve turns AI program generation from a "blind guess-and-check" process into a smart, self-correcting journey that knows exactly when to push forward, when to rest, and when to change its mind entirely.

1. Problem Statement

The paper addresses the limitations of current LLM-guided evolutionary algorithms used for automated program generation and algorithm discovery.

Context: The field is shifting from one-shot generation to inference-time search, where LLMs act as semantic mutation operators within evolutionary loops.
The Bottleneck: Existing frameworks (e.g., OpenEvolve, AlphaEvolve) rely on static schedules and fixed hyperparameters (mutation rates, exploration/exploitation ratios, prompt templates).
The Issue: Evolutionary search is non-stationary; the dynamics of the search process change over time. Static policies fail to adapt, leading to:
- Computational Waste: Resources are indiscriminately allocated to stagnating populations while promising frontiers are under-exploited.
- Fragility: Developers must manually tune hyperparameters for every new problem.
- Stagnation: Algorithms often get stuck in local optima because they cannot autonomously shift from exploration to exploitation or generate new high-level strategies when progress halts.

2. Methodology: The AdaEvolve Framework

AdaEvolve reformulates LLM-driven evolution as a hierarchical adaptive optimization problem. Instead of fixed rules, it uses a single "accumulated improvement signal" ( $G_t$ ) to drive decisions across three coupled levels.

Core Signal: Accumulated Improvement

For each subpopulation (island), the system tracks a scalar signal $G_t$ , updated as an exponential moving average of squared normalized fitness improvements ( $\delta_t$ ).

High $G_t$ : Indicates a productive trajectory (steep gradient).
Low $G_t$ : Indicates stagnation or convergence.

Level 1: Local Adaptation (Within-Island Exploration Intensity)

Goal: Dynamically modulate the balance between exploration (searching new regions) and exploitation (refining current solutions) within a specific island.
Mechanism: The exploration intensity $I_t$ $I_{t}$ is a function of $G_t$ $G_{t}$ .
- If $G_t$ is high (productive), $I_t$ decreases, favoring exploitation (selecting parents based on fitness).
- If $G_t$ is low (stagnant), $I_t$ increases, favoring exploration (selecting parents uniformly at random and using prompts that encourage orthogonal solutions).
Benefit: Eliminates the need for manual "restart" thresholds or fixed exploration rates.

Level 2: Global Adaptation (Across-Island Resource Allocation)

Goal: Route the global computational budget (LLM calls) to the most productive islands.
Mechanism: Modeled as a Multi-Armed Bandit problem.
- Global Normalization: Unlike naive bandits that reward local improvements, AdaEvolve calculates rewards relative to the global best fitness ( $f^*_{global}$ ). This prevents the system from wasting resources on islands that are merely refining poor local solutions.
- Selection: Uses an Upper Confidence Bound (UCB) algorithm with decayed cumulative rewards to select which island to query next.
- Dynamic Spawning: If all islands stagnate, the system automatically spawns new islands with random seed programs to explore alternative solution spaces.
- Migration: Periodic ring migration allows top programs to move between islands, propagating successful traits without corrupting the UCB statistics of the receiving island.

Level 3: Meta-Guidance (Solution Tactics Generation)

Goal: Escape conceptual local optima where code refinement is no longer yielding progress because the underlying algorithmic approach is suboptimal.
Mechanism: Triggered when global progress stalls (low $G_t$ $G_{t}$ across all islands).
- A separate "System 2" LLM analysis is invoked to review the problem, evaluator, and recent failures.
- It generates high-level solution tactics (e.g., "switch from greedy selection to dynamic programming" or "use SLSQP for continuous optimization").
- These tactics are injected into the mutation prompts, forcing a qualitative shift in the search trajectory rather than just numerical tweaking.

3. Key Contributions

Unified Adaptive Framework: Introduces a single framework that unifies search intensity, resource allocation, and strategy generation under one adaptive controller, replacing ad-hoc heuristics.
Globally-Normalized Resource Allocation: Proposes a novel bandit-based scheduler that evaluates improvements relative to the global best, ensuring compute is directed toward the current frontier of the search rather than local optima.
Robust Generalization: Demonstrates that the framework requires minimal configuration (only model name and iteration count) and performs consistently across diverse problem types without per-task tuning.

4. Experimental Results

The authors evaluated AdaEvolve on 185 distinct optimization problems across three categories:

Mathematical Optimization (6 problems):
- Outperformed open-source baselines (OpenEvolve, GEPA, ShinkaEvolve) and proprietary models (AlphaEvolve).
- Circle Packing (N=26): Achieved a score of 2.636, surpassing the Human SOTA (2.634) and AlphaEvolve (2.635).
- Consistently beat baselines on deceptive landscapes like Heilbronn Triangles and MinMax Distance.
ADRS Systems Benchmarks (7 real-world tasks):
- Tasks included expert parallelism load balancing, transaction scheduling, and multi-cloud storage cost minimization.
- AdaEvolve achieved the strongest aggregate performance, winning on all 7 tasks across both GPT-5 and Gemini-3-Pro backbones.
- Showed particular strength in tasks with sparse or bursty improvements where static strategies failed.
Frontier-CS (172 open-ended algorithm design problems):
- AdaEvolve achieved a mean score of 61.33, significantly outperforming OpenEvolve (50.75) and ShinkaEvolve (47.79).
- Demonstrated a 3x improvement over single-call GPT-5 (which had a median score of 0), highlighting the necessity of search scaffolds for hard problems.
Ablation Studies:
- Removing Meta-Guidance caused the most significant performance drop, confirming its critical role in escaping conceptual stagnation.
- Bandit-based selection was crucial for signal processing tasks, while Local Adaptation was vital for circle packing.

5. Significance

Paradigm Shift: Moves the field from static, manually-tuned evolutionary loops to autonomous, adaptive optimization.
Efficiency: Drastically reduces computational waste by dynamically reallocating resources away from stagnating populations.
Scalability: Proves that inference-time scaling laws can be effectively harnessed for complex algorithm discovery without requiring massive training data or human intervention.
State-of-the-Art: Sets new records in algorithmic discovery, surpassing both human experts and previous AI systems in multiple domains, including combinatorial geometry and systems engineering.

In summary, AdaEvolve represents a significant step forward in automated reasoning, demonstrating that an adaptive controller can effectively manage the complex, non-stationary dynamics of LLM-driven search to solve problems that were previously intractable or required extensive human tuning.