MLEvolve: A Self-Evolving Framework for Automated Machine Learning Algorithm Discovery

2026 · Paper

---

1. Motivation

Agents for automated machine learning (MLE agents) - from AIDE’s greedy tree to MCTS-based systems - suffer three structural defects: branches of the search cannot share what they learn (information isolation), each run starts from scratch (memoryless search), and code is produced in a single pass with no staged refinement (one-shot generation).¹ MLEvolve replaces the tree with a graph and adds an experience substrate, aiming to transfer the AlphaEvolve-style evolutionary-discovery recipe to full Kaggle-grade ML pipelines while remaining general enough to beat specialized algorithm-discovery systems on their own math benchmarks.¹²

---

2. Methodology

2.1 Search Structure

The search space is a directed graph $G=(V,E)$ with $E = E_T \cup E_{\mathrm{ref}}$ (Eq. 2). Primary edges $E_T$ encode parent→child generation and carry selection and credit assignment; reference edges $E_{\mathrm{ref}}$ connect nodes across branches and levels for information reuse but are excluded from backpropagation. When $E_{\mathrm{ref}}=\varnothing$, the search reduces to standard MCTS.² The loop follows MCTS phases - selection, expansion, simulation, backpropagation - under a progressive exploration schedule designed so the Shannon entropy $H(\pi_t)$ of branch selection decreases over time: UCT with a time-decaying exploration constant $c(t)$ annealed from $c_0$ to $c_{\min}$ (Eq. 3), plus a soft strategy switch

$$P(S_t=\mathrm{UCT}) = w(t), \qquad P(S_t=\mathrm{Elite}) = 1-w(t),$$

with $w(t)$ decaying from 1.0 to $w_{\min}$ (Eq. 4). Elite-Guided exploitation samples from a global top-$K$ set weighted by inverse rank (Eq. 5). Empirically, effective active branches $\exp(H(\pi_t))$ decay from 4.8 to 2.8, versus roughly uniform for vanilla MCTS.²

2.2 State Representation

Each node $v$ is a complete candidate ML solution - preprocessing, feature engineering, model training, prediction - formalized as $s^* = \arg\max_s h(T,s)$ (Eq. 1).² Node records carry plan, code, metrics, analysis, and feedback; lifecycle states are Draft / Improve / Debug / Evolution / Fusion / Aggregation, plus Top/Best markers.²

2.3 Generation Mechanism

Generation is planner–coder decoupled. The planner decides what to modify and why, at module level, using execution feedback, branch trajectories, and retrieved memory; the coder implements how in one of three adaptive modes: Base (full rewrite from scratch, for initial drafting), Stepwise (module-by-module following the planner spec), and Diff (targeted patches for localized refinement).² Four expansion operators instantiate $v_{\mathrm{new}} = g_o(v_t, R)$ (Eq. 6), differing in the retrieved context $R$:

1. Primary expansion: $R = \varnothing$.
2. Intra-branch evolution: $R$ = nearest $k$ ancestors in the same branch.
3. Cross-branch reference: $R$ = top-$N$ nodes across branches, triggered by branch stagnation.
4. Multi-branch aggregation: $R$ = top trajectories merged into a new branch root, triggered by global stagnation.

These are implemented by nine specialized agents (Draft, Improve, Debug, Evolution, Fusion, Aggregation, Code Review, Data Leakage, Result Parse), backed by Gemini-3.1-Pro-preview at temperature 1.0.²

2.4 Evaluation & Grounding

The simulation step executes candidate code in an interpreter and parses outputs for the task metric. A shaped immediate reward (Eq. 7) assigns $-1$ for execution failure or no valid metric, $+1$ for success without branch-best improvement, and $+2$ for refreshing the branch best.² MLE-Bench scoring uses Kaggle medal thresholds over 75 competitions; the 15 math tasks reuse AlphaEvolve’s evaluators.²

2.5 Memory / Information Flow

Retrospective Memory combines (a) a static, manually curated domain knowledge base (candidate models + usage guidelines per task type, retrieved by keyword matching, Eq. 10) for cold start, and (b) a dynamic global memory accumulating structured records (plan, outcome, analysis, feedback) after each valid execution.² Retrieval is hybrid: BM25 lexical scoring plus FAISS semantic search over BGE-base-en-v1.5 embeddings, fused by Reciprocal Rank Fusion (Eq. 11). Retrieval is stage-aware - successful/failed experiences refine plans at planning time, and the error message becomes the query during debugging. The claimed differentiator is that experience accumulates “without requiring additional LLMs for explicit reflection.”²

2.6 Selection & Propagation

Selection is UCT on the tree backbone only; rewards backpropagate along $E_T$ only: $N_u \mathrel{+}= 1$, $W_u \mathrel{+}= R(v)$, $Q_u = W_u/(N_u+\varepsilon)$ (Eqs. 8–9).² Multi-level stagnation control drives propagation: after $\tau_{\mathrm{branch}}$ consecutive non-improving expansions, intra-branch evolution (later cross-branch reference) fires; after $\tau_{\mathrm{global}}$ steps without global-best improvement, multi-branch aggregation merges top trajectories. The final submission is an ensemble of graph-level top-$K$ nodes.²

2.7 Anti-Slop / Anti-Hallucination Mechanisms

A Code Review Agent screens every generated program for naming/import errors, suspicious patterns, and metric consistency before execution. A Data Leakage Agent “checks for potential leakage between training and evaluation splits to prevent overfitting to evaluation artifacts and avoid inflated scores.” A Debug Agent repairs failures from error traces with minimal modifications up to a retry limit, and the $-1$ failure reward prevents unverifiable proposals from accruing credit; the Result Parse Agent structures logs back into the loop.²

---

3. Results

• MLE-Bench (75 tasks, mean ± SEM over 3 seeds): 65.3% overall medal rate (80.3 low / 64.0 medium / 46.7 high complexity), 100% valid submissions, 76.0% above-median, 34.7% gold - under a 12 h budget. Baselines (24 h unless noted): AIBuildAI (Claude-Opus-4.6) 63.1%; MARS+ 62.7%; ML-Master 2.0 56.4%; R&D-Agent (GPT-5) 35.1%; AIRA-Dojo (o3) 31.6%; AIDE (o1-preview) 17.1%.² Budget: max 500 expansion steps, 21 vCPUs, 234 GB RAM, 1× H200 per task.²
• Math generalization (15 AlphaEvolve tasks): best on 11/15 vs. AlphaEvolve,³ AlphaEvolve-v2,⁴ SimpleTES, TTT-Discover, and OpenEvolve⁵ - e.g., first autocorrelation inequality 1.5028628749 vs. OpenEvolve’s 1.5028628983 and AlphaEvolve’s 1.5052939684; circle packing 2.6359830395 vs. AlphaEvolve’s 2.6358627564.²
• Ablations (MLE-Bench Lite, 22 tasks): removing Progressive MCGS drops medals 81.82%→68.18% (largest drop); removing Retrospective Memory 81.82%→68.18%; removing Adaptive Code Generation →72.73%. Mechanism-level: removing intra-branch evolution collapses medals 66.67%→33.33%.²

Baseline numbers are partly taken “from the MLE-Bench leaderboard or the corresponding papers,” not re-run under matched conditions.²

---

4. Limitations & Assumptions

Reward shaping is task-metric-specific; the static knowledge base is manually curated; math-task comparisons reuse AlphaEvolve evaluators across methods with different LLM backbones and budgets (not compute-matched).² Exact stagnation thresholds and schedule constants ($c_0, c_{\min}, w_{\min}, \tau$) live in an appendix whose values were not audited here; the arXiv HTML rendering is truncated after §4.2 (the PDF is authoritative). The 2026-dated tables reference very recent models (Gemini-3.1-Pro-preview, GPT-5.5), so benchmark-leakage and comparability caveats apply.

---

5. Critical Analysis

• Distinctive strength: reference edges with no credit assignment are a clean formal solution to cross-branch information flow - transfer without contaminating UCT statistics - and the entropy-decay schedule makes the exploration→exploitation shift measurable rather than anecdotal.²
• Structural weakness / trade-off: the architecture is heavy - nine agents, a curated knowledge base, an embedding index, shaped rewards with per-task bounds - and the strongest ablated component (intra-branch evolution, halving medals when removed) is a conventional within-branch refinement loop, so how much of the gain is attributable to the graph machinery itself remains open.
• Connections: MLEvolve benchmarks directly against AlphaEvolve (#4) and AlphaEvolve-v2 on their own 15 math tasks and against OpenEvolve (#7) as a named baseline.² Its MLE-Bench protocol and medal metric connect it to Theme-4 systems - AIDE (#15) (17.1%) and MARS (#17) (MARS+ 62.7%) - which it surpasses at half the runtime.² Conceptually it is the graph-search counterpoint to the archive-of-programs design of FunSearch (#6).

---

6. References

Footnotes

1. Du et al., “MLEvolve: A Self-Evolving Framework for Automated Machine Learning Algorithm Discovery,” arXiv:2606.06473 - https://arxiv.org/abs/2606.06473 ↩ ↩²

2. MLEvolve full text (PDF; arXiv HTML is truncated after §4.2) - https://arxiv.org/pdf/2606.06473 ; code: https://github.com/InternScience/MLEvolve ↩ ↩² ↩³ ↩⁴ ↩⁵ ↩⁶ ↩⁷ ↩⁸ ↩⁹ ↩¹⁰ ↩¹¹ ↩¹² ↩¹³ ↩¹⁴ ↩¹⁵ ↩¹⁶ ↩¹⁷ ↩¹⁸ ↩¹⁹ ↩²⁰ ↩²¹ ↩²² ↩²³

3. Novikov et al., “AlphaEvolve: A coding agent for scientific and algorithmic discovery,” arXiv:2506.13131 - https://arxiv.org/abs/2506.13131 ↩

4. Georgiev, Gómez-Serrano, Tao & Wagner, “Mathematical exploration and discovery at scale,” arXiv:2511.02864 - https://arxiv.org/abs/2511.02864 ↩

5. OpenEvolve repository - https://github.com/algorithmicsuperintelligence/openevolve ↩