Controlled Self-Evolution (CSE) is a novel framework that dramatically improves exploration efficiency in code optimization. Unlike existing self-evolution methods that suffer from initialization bias, uncontrolled stochastic operations, and insufficient experience utilization, CSE addresses all three bottlenecks through:

Generates multiple structurally distinct algorithmic strategies before evolution begins, ensuring broad coverage of the solution space:

• Multi-paradigm exploration: DP, Greedy, Two Pointers, Bit Manipulation, etc.
• Sketch instantiation: Transform abstract strategies into concrete implementations
• Initial population: Create diverse starting points to avoid local optima

Replaces stochastic operations with fine-grained feedback-guided mechanisms:

• Slot-based decomposition: Decompose solutions into functional components
• Targeted refinement: Fix faulty components while preserving high-performing parts
• Priority-guided: Optimize bottlenecks, inherit good parts, inspect risky areas

• Complementary combination: Merge strengths from different solution trajectories
• Structural integration: Create cohesive hybrid implementations
• Synergistic synthesis: Achieve 1+1>2 effects through intelligent merging

Captures and reuses evolutionary insights at two levels:

CSE consistently outperforms all baselines across diverse LLM backbones (Qwen3-235B-A22B, DeepSeek-v3-0324, Claude-4.5-Sonnet, GPT-5):

Metrics: ET (Execution Time efficiency), MP (Memory Peak efficiency), MI (Memory-time Integral - our primary metric balancing both runtime and memory)

CSE achieves higher efficiency from early generations and maintains continuous improvement throughout evolution:

Key Observations:

• 🚀 Fast Start: CSE outperforms baselines from the first generation
• 📈 Sustained Growth: Continuous improvement without plateauing
• 🎯 Efficiency: Achieves superior results with limited exploration budget

Detailed evolution trajectory on a real optimization task, showing how CSE progressively discovers more efficient algorithms:

Evolution Highlights:

• Iter 1: Initial solution with basic approach (886.13 MI)
• Iter 5: Strategy switch to square-root factorization (197.49 MI)
• Iter 8: Controlled mutation improves factor-checking (176.89 MI)
• Iter 22: Trial division with early-stop optimization
• Iter 25: Crossover combines best features → Final: 93.93 MI (7× improvement!)

Get CSE running in 3 steps:

# 1. Clone and install
git clone https://github.com/your-repo/EvoControl.git
cd EvoControl
conda create -n cse python=3.12
conda activate cse
pip install -e .

# 2. Configure API credentials in configs/Plan-Weighted-Local-Global-30.yaml
# Set model.api_key, model.api_base, etc.

# 3. Run your first experiment
python SE_Perf/instance_runner.py \
    --config configs/Plan-Weighted-Local-Global-30.yaml \
    --max-parallel 10 \
    --mode execute

💡 Prerequisites: Ensure EffiBench-X backend is running for code evaluation

# Create virtual environment
conda create -n cse python=3.12
conda activate cse

# Install dependencies
pip install -e .

CSE uses a two-layer configuration system:

Required Settings (in strategy config):

model:
  name: "deepseek-chat" # LLM model name
  api_base: "https://api.deepseek.com/v1"
  api_key: "your-api-key" # 🔑 Required!

global_memory_bank:
  enabled: true
  embedding_model:
    model: "text-embedding-3-small"
    api_key: "your-embedding-key" # 🔑 Required!

python SE_Perf/instance_runner.py \
    --config configs/Plan-Weighted-Local-Global-30.yaml \
    --max-parallel 10 \
    --mode execute

python SE_Perf/instance_runner.py \
    --config configs/Plan-Weighted-Local-Global-30.yaml \
    --max-parallel 1 \
    --limit 5 \
    --mode execute

trajectories_perf/experiment_{timestamp}/
├── {instance_name}/
│   ├── iteration_{n}/          # Per-iteration results
│   │   ├── result.json         # Evaluation metrics
│   │   └── *.traj              # Solution trajectories
│   ├── final.json              # Best optimized solution
│   ├── traj.pool               # All attempted solutions
│   └── se_framework.log        # Execution logs
├── all_hist.json               # Aggregated history
├── final.json                  # All final solutions
└── total_token_usage.json      # API usage statistics

To run experiments on the complete EffiBench-X dataset, you need to download the full instances from the official repository:

# Clone the EffiBench-X repository
git clone https://github.com/EffiBench/EffiBench-X.git
cd EffiBench-X

# Install dependencies
pip install -r requirements.txt

# Download dataset from Hugging Face Hub
python hf_dataset.py download

Then copy the downloaded instances to your EvoControl project.

After downloading, the instances/ directory should contain JSON files:

instances/
├── aizu_1444_yokohama-phenomena.json
├── aizu_1459_e-circuit-is-now-on-sale.json
├── leetcode_123_best-time-to-buy-and-sell-stock.json
├── codeforces_1234_some-problem.json
└── ... (600+ problem instances from LeetCode, AtCoder, CodeChef, Codeforces, AOJ)

# Run on all instances with high parallelism
python SE_Perf/instance_runner.py \
    --config configs/Plan-Weighted-Local-Global-30.yaml \
    --instances-dir ./instances \
    --max-parallel 20 \
    --mode execute

# Or run on a subset (first 100 instances)
python SE_Perf/instance_runner.py \
    --config configs/Plan-Weighted-Local-Global-30.yaml \
    --instances-dir ./instances \
    --max-parallel 10 \
    --limit 100 \
    --mode execute

CSE provides an interactive web-based visualization tool for analyzing experiment results, including trajectory graphs, performance curves, and detailed LLM interactions.

# Set the root directory for your experiments
export VIZ_ROOT="trajectories_perf/your_experiment_dir"

# Start the visualization server
cd viz_tool
python app.py

Then open your browser and navigate to: http://localhost:5000

• Select Experiment: Choose from available experiment directories
• Select Instance: Pick a specific problem instance to visualize
• Compare with: Optionally select another experiment for comparison
• Tabs:
  • Problem: View the original problem description
  • Details: Node metrics and summary information
  • LLM IO: Full LLM conversation history per iteration
  • Code: Generated solution code
  • Full Data: Raw JSON data for debugging

# View results from a specific experiment
export VIZ_ROOT="trajectories_perf/Plan-Weighted-Local-Global-30its_20260109_205036"
python viz_tool/app.py

# Change port if 5000 is occupied
python viz_tool/app.py --port 8080

If you find EvoControl useful in your research, please cite our paper:

@article{hu2026controlled,
  title={Controlled Self-Evolution for Algorithmic Code Optimization},
  author={Tu Hu and Ronghao Chen and Shuo Zhang and Jianghao Yin and Mou Xiao Feng and Jingping Liu and Shaolei Zhang and Wenqi Jiang and Yuqi Fang and Sen Hu and Yi Xu and Huacan Wang},
  journal={arXiv preprint arXiv:2601.07348},
  year={2026}
}

📄 Paper: arXiv:2601.07348

We thank the following projects:

• EffiBench-X — Code efficiency evaluation benchmark
• SE-Agent — Trajectory-level self-evolution
• OpenEvolve — Open-source implementation of AlphaEvolve