Skip to main content
Back

Shanghai AI Lab's MLEvolve Beats Every MLE Agent at Half the Compute

MLEvolve beats AlphaEvolve and every MLE agent on the leaderboard using half the standard compute budget, with a new graph search and memory system that lets agents actually learn from past runs.

  • New SOTA on MLE-Bench: MLEvolve achieves a 65.3% average medal rate on 75 Kaggle tasks in just 12 hours, beating all prior agents running on 24-hour budgets.
  • Beats AlphaEvolve: A general-purpose MLE agent outperforms Google DeepMind's specialized AlphaEvolve on its own mathematical optimization benchmark tasks.
  • Progressive MCGS: Upgrades Monte Carlo Tree Search to a graph structure with reference edges, enabling cross-branch knowledge sharing and 4 expansion strategies.
  • Retrospective Memory: A two-layer memory (static domain knowledge base + dynamic runtime memory) lets the agent reuse past successes and avoid repeated failures.
  • Hierarchical planning: Separates strategy (Planner) from implementation (Coder), with 3 adaptive coding modes to prevent unstable full rewrites.
  • Open source: Code available at github.com/InternScience/MLEvolve; uses Gemini-3.1-Pro-preview as the backbone LLM.

LLM agents that can autonomously run machine learning experiments have been improving fast, but they all share a frustrating blind spot: each iteration starts nearly from scratch. A new framework from Shanghai AI Lab called MLEvolve attacks that problem head-on, introducing a self-evolving multi-agent system that accumulates experience, shares knowledge across search branches, and adapts its strategy over time. The result is state-of-the-art performance on MLE-Bench in just 12 hours -- half the compute budget that competing systems use.

The Three Cracks in Every MLE Agent

To understand why MLEvolve matters, you need to understand what existing agents get wrong. When an LLM agent explores a solution space, it typically builds a search tree -- each branch is a different approach to the problem. The issue is that these branches are completely isolated from each other.

  • Inter-branch isolation: A winning trick discovered in branch A never reaches branch B. If branch B tries the same dead end, it has no way to know it already failed elsewhere.
  • Memoryless search: Each planning decision is made in a vacuum. Past successes and failures don't accumulate into reusable knowledge -- only a scalar reward propagates back up the tree.
  • No hierarchical control: Most agents conflate what to change with how to implement it in a single generation step. This leads to unstable, full-rewrite iterations that undo good work as often as they improve it.

These aren't minor inefficiencies. Together they mean that after dozens of iterations, an agent isn't meaningfully smarter than it was at iteration one. MLEvolve is built to fix all three at once.

MLEvolve system overview showing Plan, Generate, Execute, Evolve cycle with Progressive MCGS, Retrospective Memory, and Adaptive Code Generation components

From Tree to Graph: Progressive MCGS

The core search mechanism in MLEvolve is called Progressive Monte Carlo Graph Search (MCGS). Standard MCTS (Monte Carlo Tree Search -- the same algorithm behind AlphaGo) organizes candidates in a tree, where each node is a solution and children are derived from their parent. MLEvolve upgrades this to a directed graph by adding a second type of edge: