Source-linked AI summary
DeltaEvolve: Accelerating Scientific Discovery through Momentum-Driven Evolution
Jiachen Jiang, Tianyu Ding, Zhihui Zhu
TL;DR
Existing LLM evolutionary agents struggle with context inefficiency and weak guidance from full-code histories. DeltaEvolve formalizes evolution as EM, uses structured semantic deltas with multi-level progressive disclosure, and achieves comparable or superior solution quality with lower token consumption across scientific domains. The paper is scoped to program-expressed solutions and assumes fixed model parameters with black-box LLM access.
Problem
Existing evolving agents face limited context and weak evolutionary guidance because full-code histories are costly and obscure which changes improved performance.
Method
DeltaEvolve optimizes the EM M-step by storing transferable semantic deltas in a multi-level database and progressively disclosing historical information.
Results
DeltaEvolve achieves comparable or superior solution quality while reducing total token consumption by approximately 36.79% on average across five scientific domains.
Takeaways & Limitations
Momentum-based semantic history can improve context use for automated scientific discovery across diverse domains.
Takeaways & Limitations
The formulation assumes fixed model parameters and black-box LLM API access, and focuses on solutions or discovery procedures expressible as programs.
Abstract
from arXiv · showhide
LLM-driven evolutionary systems have shown promise for automated science discovery, yet existing approaches such as AlphaEvolve rely on full-code histories that are context-inefficient and potentially provide weak evolutionary guidance. In this work, we first formalize the evolutionary agents as a general Expectation-Maximization framework, where the language model samples candidate programs (E-step) and the system updates the control context based on evaluation feedback (M-step). Under this view, constructing context via full-code snapshots constitutes a suboptimal M-step, as redundant implement details dilutes core algorithmic ideas, making it difficult to provide clear inspirations for evolution. To address this, we propose DeltaEvolve, a momentum-driven evolutionary framework that replaces full-code history with structured semantic delta capturing how and why modifications between successive nodes affect performance. As programs are often decomposable, semantic delta usually contains many effective components which are transferable and more informative to drive improvement. By organizing semantic delta through multi-level database and progressive disclosure mechanism, input tokens are further reduced. Empirical evaluations on tasks across diverse scientific domains show that our framework can discover better solution with less token consumption over full-code-based evolutionary agents.
1 Introduction
DeltaEvolve reframes evolutionary program search as an EM process and replaces full-code history with semantic deltas that provide more informative guidance. Across five scientific domains, it achieves comparable or superior solution quality while reducing token consumption.
- Motivation: Existing evolving agents face limited context windows and insufficient evolutionary guidance because long full programs constrain history reuse and obscure core algorithmic ideas.These limitations motivate retaining only selected solutions while leaving less room for historical information.
- EM Framework: The framework models candidate-program generation as the E-step and context updating from evaluation feedback as the M-step.This formalization identifies context construction as the central system-improvement problem.
- DeltaEvolve: DeltaEvolve stores semantic deltas describing what changed and how performance was affected, creating a momentum-like signal for guiding later program updates.The approach replaces static full-code snapshots with directional information between parent and offspring nodes.
- DeltaEvolve: A multi-level database and progressive disclosure sampler expose full code for the current parent while compressing historical inspirations into delta summaries or plans.This preserves the logic of past improvements without spending tokens on implementation details.
- Evaluation: 36.79% average token consumption reduction accompanies comparable or superior solution quality across five scientific domains.On black-box optimization, DeltaEvolve achieves higher scores with fewer input tokens across context settings.
2 Related Works
Related work established LLM-driven evolutionary coding agents and developed general methods for context organization, memory, and compression. DeltaEvolve differs by constructing optimization-aware context rather than applying generic compression alone.
- Evolutionary Coding Agents: AlphaEvolve and OpenEvolve established the viability of integrating LLMs with evolutionary algorithms for program evolution.Subsequent work has focused on improving orchestration of the search process.
- Context Engineering: Context-engineering research studies modular prompts, progressive disclosure, long-term memory, and compression for long-horizon reasoning.These methods aim to manage context length while preserving task-relevant information.
- Context Engineering: DeltaEvolve constructs context with awareness of optimization objectives instead of merely reducing context length generically.Its distinction is optimization-directed context construction.
3 Evolutionary Framework
The framework casts LLM-driven program evolution as zero-order black-box optimization within an EM process, where candidate sampling and context construction alternate. It identifies context policy design as the key optimization step and shows that evaluator-guided selection matters more than scalar scores alone.
- 3.1 Problem Definition: LLM-driven discovery searches program spaces for high-scoring solutions using evaluators that provide feedback without accessible analytical gradients.The setting covers scientific and engineering tasks whose solutions can be expressed as executable programs.
- 3.2 The EM Interpretation: In the E-step, the LLM samples candidate programs from the current context and obtains evaluator feedback for the new history.The sampled candidates estimate the local search landscape.
- 3.2 The EM Interpretation: In the M-step, a policy updates the next context from accumulated history to maximize expected future score.With fixed model weights, context construction is the principal optimization target.
- 3.2 The EM Interpretation: Using only a parent program can cause mode collapse by repeatedly generating similar modifications, limiting exploration and escape from local optima.The framework compares this greedy refinement strategy with hillclimbing.
- 3.3 Context Selection Dominates Scalar Feedback: Removing selection while retaining visible scores causes performance to collapse, whereas removing numerical scores produces performance similar to standard AlphaEvolve.These controlled results indicate that high-quality contextual examples, rather than scalar feedback alone, primarily guide improvement.
4 DeltaEvolve
DeltaEvolve reformulates evolutionary context construction as an M-step and replaces redundant full-code history with transferable semantic deltas. A multi-level database and progressive disclosure sampler expose the right abstraction level for each historical node while retaining executable parent code.
- Motivation: The framework identifies context construction as the decisive M-step governing the evolutionary trajectory.
- Semantic Delta: Semantic delta records interpretable logic changes between successive programs, isolating transferable components rather than preserving entire solutions.
- Semantic Delta: Delta inspirations use qualitative performance shifts such as “Improved” or “Degraded” instead of precise numerical changes.
- Semantic Delta: Accumulated semantic deltas act as a discrete semantic analogue of momentum, encoding the prevailing direction of improvement across iterations.
- Multi-Level Database: Each database node stores a delta summary, delta plan details, and full executable code as Levels 1, 2, and 3.
- Progressive Disclosure Sampler: Progressive disclosure renders older elites as summaries, recent or selected inspiration nodes as plans, and the parent as full code for modification.
5 Experiments
The experiments evaluate solution quality and token consumption across open-ended tasks and compare DeltaEvolve with sampling, refinement, and full-code evolutionary baselines. Across five domains and three random seeds, DeltaEvolve consistently achieves better outcomes on both metrics while using fewer tokens.
- Evaluation Setup: The evaluation asks whether DeltaEvolve improves objective scores and reduces input-token costs across diverse scientific domains.
- Evaluation Setup: The benchmark covers open-ended problems including black-box optimization, hexagon packing, and symbolic regression across diverse domains.
- Baselines: Comparisons include Parallel Sampling, Greedy Refine, and AlphaEvolve, whose evolutionary search relies on full-code history.
- Metrics: Best Score measures the best objective value discovered within the fixed budget, while Token Consumption sums tokens across all model calls and iterations.
- Main Results: Across five domains and three random seeds, DeltaEvolve consistently outperforms all baselines on best score and token consumption.
- Main Results: Replacing redundant full-code snapshots with compact semantic deltas substantially lowers token consumption and enables faster, more directed evolution.
6 Conclusion
DeltaEvolve addresses context inefficiency and weak evolutionary signals in full-code self-evolving systems by using semantic delta within an EM-based framework. Its evaluations show improved solution quality and token efficiency across scientific domains.
- DeltaEvolve formalizes program evolution as an EM process and uses semantic changes in program logic as transferable improvement signals.Algorithmic discovery searches discrete program spaces through evaluator feedback, so improvements arise from semantic program changes rather than numerical updates.
- The framework combines semantic delta, a multi-level database, and progressive disclosure to use evolutionary history more efficiently.These components replace static full-code snapshots with structured information about how and why programs improve.
- Experiments across diverse scientific domains report superior solution quality while significantly improving token efficiency over full-code evolutionary systems.
B Algorithm of Progressive Disclosure Sampler
The progressive disclosure sampler selects historical nodes and renders them at different abstraction levels, while the current parent remains available as full code. This preserves evolutionary signals while reducing context length.
- Node Selection: The sampler selects a parent, elite nodes, and diverse alternatives before constructing the historical context.Selection uses a parent policy, top-k scoring, and MAP-Elites sampling.
- Progressive Rendering: Recent historical nodes are rendered with delta plans, while older inspiration nodes are rendered with concise delta summaries.
- Progressive Rendering: The selected parent is appended as full code so the model can edit it directly.
- Prompt Design: DeltaEvolve’s prompts replace full-code inspiration contexts with concise summaries and plans that expose strategy differences and rationales.The system prompt requires structured Delta Summaries and Delta Plans alongside generated code.
D.1 Blackbox Optimization
The black-box optimization evaluation tests DeltaEvolve on BBOB functions using a two-stage validity and scoring protocol. In a representative run, DeltaEvolve achieves higher final score with lower token usage than AlphaEvolve.
- Task Description: The task minimizes continuous BBOB objectives using only problem dimension, bounds, and evaluation budget, without gradients or analytical function forms.
- Initial Programs: The initial baseline is memory-less Random Search with uniform sampling and keep-best selection.
- Evaluator: The evaluator tests five BBOB functions and combines solution quality with efficiency in the final score.Validity filtering precedes final scoring, while the value score depends on normalized improvement relative to a reference value.
- Evolution Process: DeltaEvolve achieves a significantly higher final score while maintaining lower token usage than AlphaEvolve in the representative run.Figure 7 compares combined score and cumulative token consumption across iterations using a fixed random seed.
D.2 Hexagon Packing
Across hexagon packing, symbolic regression, Krylov solving, and efficient convolution, DeltaEvolve improves task-specific solutions through structural algorithmic changes while tracking token usage. The examples show transitions from simple baselines to more specialized strategies.
- D.2 Hexagon Packing: In hexagon packing, DeltaEvolve moves beyond a lattice baseline by resolving overlaps and compressing the outer boundary through continuous relaxation.
- D.3 Symbolic Regression: In symbolic regression, DeltaEvolve transitions from a linear model to nonlinear formulations containing terms such as cubic stiffness or interaction effects.The resulting formulation sharply reduces MSE and increases the logarithmic score while retaining concise code expressions.
- D.4 Krylov Solver: For the Krylov solver, DeltaEvolve replaces the Jacobi bottleneck with a polynomial preconditioner and a residual-based restart heuristic.The evolved solver converges in significantly fewer iterations than the baseline and achieves a higher score.
- D.5 Efficient Convolution: For efficient convolution, DeltaEvolve transitions from a spatial-domain baseline to an FFT-based frequency-domain approach with O(N^2 log N) complexity.The evaluation measures speedup against the AlgoTune baseline while checking correctness and timeout constraints.
E Case Study
DeltaEvolve’s case study shows evolutionary progress through successive semantic improvements rather than undirected code rewriting. Its multi-level delta representations expose strategic shifts and implementation details at different levels of disclosure.
- Evolutionary trajectory: 1.68 → 2.11: A shift to Latin Hypercube initialization with adaptive batched local search triggered a steep performance gain.Later refinements introduced stagnation probing and Metropolis acceptance to improve budget usage and escape local optima.
- Evolutionary trajectory: The trajectory illustrates how DeltaEvolve stacks meaningful logical improvements across generations toward a robust final solution.
- Evaluation views: The case-study figures track best-so-far score across iterations and separately visualize efficiency score and token usage for Convolve2D.
- Multi-level representations: Level 1 Delta Summaries encode strategic pivots concisely, such as changing from random sampling to adaptive Latin Hypercube sampling.
- Multi-level representations: Level 2 Delta Plans expose component-level changes by contrasting OLD_LOGIC with NEW_LOGIC for initialization, polishing, and step size.
H Discovered Solutions
DeltaEvolve discovered a black-box optimization solution using CMA-ES that substantially exceeded the AlphaEvolve baseline. The implementation adapts search geometry, step sizes, population settings, and boundary handling under evaluation-budget constraints.
- Discovered solution: 3.937: DeltaEvolve’s black-box optimization score surpassed the AlphaEvolve baseline of 2.6415.The reported solution used a robust CMA-ES optimizer.
- Optimization strategy: CMA-ES adapts the search distribution’s geometry to the problem landscape by learning variable correlations and adjusting step sizes.
- Optimization strategy: The optimizer scales hyperparameters with the evaluation budget and uses boundary handling intended to preserve search direction.
- Implementation choices: The implementation controls population size to leave room for more generations and caps it for high-dimensional problems to manage computational cost.
- Search procedure: The search loop samples, bounds, evaluates, and ranks candidate populations until the evaluation budget is reached.
- Implementation choices: Covariance updates combine rank-one and rank-μ terms, with symmetry and positive-definiteness safeguards for numerical stability.