[UC Berkeley] AdaEvolve: Beyond Static LLM Search with Hierarchical Adaptive Optimization

TL;DR

The research frontier is shifting from scaling training sets to scaling inference-time compute. While current LLM-guided evolutionary algorithms use sophisticated models as "mutation operators," they suffer from brittle, static control logic. AdaEvolve solves this by introducing a hierarchical adaptive framework that treats LLM search like a dynamic control problem. It matches or beats human SOTA and proprietary models (like AlphaEvolve) across 185 benchmarks by automatically adjusting how, where, and what it explores.

Problem & Motivation: The Brittle Nature of Static Search

Current LLM-guided Evolutionary Algorithms (EAs) like FunSearch or OpenEvolve are powerful but "dumb" in their execution. They use fixed mutation rates, uniform resource allocation across subpopulations (islands), and static prompts.

If the parameters are too conservative, the search gets trapped in local optima; if they are too aggressive, the LLM fails to refine promising solutions. For complex problems like Circle Packing, previous methods required a human-in-the-loop to manually restart the process with "refinement" settings once progress stalled. The researchers at UC Berkeley asked: Can we make the search algorithm as smart as the LLM performing the mutations?

Methodology: The Three Levels of Adaptivity

AdaEvolve's core innovation is the Accumulated Improvement Signal ($G_t$), an exponential moving average of squared normalized fitness improvements. This signal acts as a "gradient analogue" for discrete, non-differentiable spaces, coordinating three levels of adaptation:

1. Local Adaptation (Intensity Control)

Within each "island" (subpopulation), AdaEvolve modulates the Exploration Intensity.

• High Improvement ($G_t\uparrow$): The search is on a productive "gradient." The system shifts toward exploitation (refinement).
• Low/No Improvement ($G_t\downarrow$): The trajectory has stagnated. The system shifts toward exploration (orthogonal solutions) to jump out of local minima.

2. Global Adaptation (Bandit-based Budgeting)

Compute is a finite resource. AdaEvolve uses a Multi-Armed Bandit (UCB) to decide which islands deserve more LLM calls. Crucially, it uses Globally-Normalized Rewards. This prevents "poor island bias," where a bad subpopulation making trivial gains gets more resources than a high-performing subpopulation making incremental but globally superior progress.

3. Meta-Guidance (Tactical Shifts)

When numerical adaptation fails, it often means the idea is the bottleneck, not the code. At this stage, AdaEvolve triggers a "System 2" meta-analysis. A separate LLM instance analyzes the problem and failed attempts to generate Solution Tactics (e.g., "Switch from greedy selection to dynamic programming"). These are then injected into mutation prompts to force a qualitative leap in strategy.

Experiments & Results

The framework was tested on a massive battery of 185 problems:

• Mathematical Optimization: On Circle Packing, it achieved a score of 2.636, beating the Human SOTA of 2.634.
• ADRS Systems Benchmarks: AdaEvolve dominated in 7 real-world tasks (like Cloud cost optimization and TXN scheduling), demonstrating that adaptivity is essential when feedback is noisy.
• Frontier-CS: On 172 open-ended algorithmic challenges, AdaEvolve achieved a median score of 75.15, compared to 0.0 for a single-call GPT-5, highlighting the power of iterative search.

Table: AdaEvolve consistently outperform baselines across various backbones (GPT-5, Gemini-3-Pro).

The Role of Meta-Guidance

Ablation studies revealed that Meta-Guidance of Level 3 is one of the most critical features. Without it, performance on complex tasks like Signal Processing plummeted, as the system lacked the "introspection" needed to pivot to entirely new mathematical frameworks (like moving from Savitzky-Golay to Spline-based smoothing).

Critical Insight & Conclusion

AdaEvolve proves that inference compute scaling shouldn't just be about "more calls," but about "smarter allocation." By unifying three levels of feedback into a single adaptive optimizer, it replaces manual hyperparameter tuning with an autonomous, self-regulating search engine.

Future Outlook: As LLM costs drop and test-time compute becomes the primary driver of capability, frameworks like AdaEvolve will likely become the standard "operating system" for AI-driven scientific discovery and systems engineering.

Main Takeaway: Don't give an LLM a fixed map; give it a compass (Improvement Signal) and the power to change its route (Meta-Guidance).