Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/skydiscover-ai/skydiscover/llms.txt

Use this file to discover all available pages before exploring further.

​
Overview

AdaEvolve is an adaptive evolutionary search algorithm that dynamically adjusts its optimization behavior based on observed progress. It uses a multi-island architecture where each island evolves independently, with migration between islands and adaptive exploration/exploitation control.

Research Paper

Read the full AdaEvolve paper on ArXiv

​
Key Features

Multi-Island Evolution

Multiple parallel populations evolve simultaneously with periodic migration of top solutions

Adaptive Search Intensity

Dynamically adjusts exploration vs exploitation based on improvement signals

UCB Island Selection

Upper Confidence Bound algorithm selects which island to evolve next

Paradigm Breakthroughs

Generates high-level strategy shifts when globally stuck

​
How It Works

​
Adaptive Search Intensity

AdaEvolve tracks improvement history per island using two key metrics:
  • Improvement Signal (δ): Normalized magnitude of fitness improvement
  • Accumulated Signal (G): Decayed sum of squared improvements
The search intensity for each island is calculated based on its accumulated improvement signal, determining the balance between exploration (trying diverse approaches) and exploitation (refining known good solutions).

​
Island-Based Evolution

The algorithm maintains multiple independent populations (islands) that evolve in parallel:
  1. Round-robin selection: Islands take turns evolving using UCB-based selection
  2. Migration: Top solutions periodically migrate between islands
  3. Independent adaptation: Each island has its own search intensity

​
Paradigm Breakthroughs

When progress stagnates globally across all islands, AdaEvolve can generate “paradigm breakthroughs” - high-level strategic ideas that represent fundamentally different approaches to the problem.

​
Configuration

​
Basic Usage

skydiscover-run initial_program.py evaluator.py \
  --search adaevolve \
  --iterations 100

​
Configuration File

search:
  type: adaevolve
  database:
    # Island configuration
    num_islands: 5
    population_size: 40
    
    # Adaptive search
    use_adaptive_search: true
    gamma_decay: 0.95           # Decay factor for accumulated improvement
    
    # Migration settings
    migration_interval: 10       # Iterations between migrations
    migration_rate: 0.1          # Fraction of population to migrate
    
    # Paradigm breakthroughs
    use_paradigm_breakthrough: true
    paradigm_stagnation_threshold: 20
    paradigm_num_to_generate: 3
    
    # Error handling
    enable_error_retry: true
    max_error_retries: 2

​
Configuration Options

​
num_islands
int
default:"5"
Number of independent populations to maintain
​
population_size
int
default:"40"
Maximum number of programs per island
​
use_adaptive_search
bool
default:"true"
Enable adaptive exploration/exploitation control
​
gamma_decay
float
default:"0.95"
Decay factor for accumulated improvement signal (0-1)
​
migration_interval
int
default:"10"
Number of iterations between island migrations
​
migration_rate
float
default:"0.1"
Fraction of top programs to migrate between islands
​
use_paradigm_breakthrough
bool
default:"false"
Enable paradigm breakthrough generation when stuck
​
paradigm_stagnation_threshold
int
default:"20"
Iterations without improvement before triggering paradigm generation
​
paradigm_num_to_generate
int
default:"3"
Number of paradigm ideas to generate per breakthrough

​
When to Use AdaEvolve

  • Complex optimization problems with multiple local optima
  • Problems where both exploration and exploitation are important
  • Long discovery runs (100+ iterations) where adaptation can help
  • Problems requiring diverse solution approaches
  • Very short discovery runs (< 20 iterations)
  • Problems with clear single optimal approach
  • When simplicity is prioritized over performance

​
Performance

Across ~200 optimization benchmarks, AdaEvolve achieves:
  • Frontier-CS: ~34% median score improvement over OpenEvolve, GEPA, and ShinkaEvolve
  • Math + Systems: Matches or exceeds AlphaEvolve and human SOTA on 6/6 systems and 6/8 math tasks
  • Real-world impact: 41% lower cross-cloud transfer cost, 14% better GPU load balance

​
Example: Circle Packing

# Run AdaEvolve on the circle packing benchmark
uv run skydiscover-run \
  benchmarks/math/circle_packing/initial_program.py \
  benchmarks/math/circle_packing/evaluator.py \
  --config benchmarks/math/circle_packing/config.yaml \
  --search adaevolve \
  --iterations 100

​
Advanced Features

​
Sibling Context

AdaEvolve provides the LLM with information about previous mutations of the same parent (“siblings”), helping it learn from recent attempts.

​
Mode-Aware Prompting

The prompt automatically adapts based on whether the current mode is:
  • Exploration: Encourages diverse, creative approaches
  • Exploitation: Encourages refinement and optimization

​
Comprehensive Logging

AdaEvolve logs detailed statistics to a JSON file including:
  • Search intensity per island
  • Improvement signals
  • Island populations and best scores
  • UCB selection scores
Access via adaevolve_iteration_stats_*.jsonl in the output directory.
  • EvoX - Co-evolves the search strategy itself
  • Top-K - Simpler top-K selection without adaptation
  • OpenEvolve Native - MAP-Elites with island architecture

Build docs developers (and LLMs) love

Get started for freeTalk to us