Summary (Overview)

• OpenMLE is an open full-stack system for recursive self-improvement (RSI) in machine learning engineering (MLE), comprising three components: OpenMLE-Gym (verifiable task environments), OpenMLE-ERL (operator learning via execution-grounded SFT and RL), and OpenMLE-Evo (long-horizon evolutionary search).
• The system trains four atomic program-evolution operators—Draft, Improve, Debug, Crossover—which serve as a shared interface between post-training and inference, forming a meta-evolutionary loop where the trained model becomes the variation engine of the search harness.
• Frontis-MA1-35B (the primary model) improves Medal Average on MLE-Bench Lite from 39.39% (Qwen3.6-35B-A3B base) to 60.61% under OpenMLE-Evo, and to 71.21% with OpenMLE-Evo-Max, exceeding GPT-5.5+Codex and approaching GPT-5.6 Sol and Kimi K3.
• On the held-out NatureBench Lite (10 tasks), both components transfer: swapping the trained model raises Match-SOTA from 50% to 70%; swapping in OpenMLE-Evo raises it from 20% to 50%.
• The full stack (model weights, datasets, training/evaluation code, sandbox infrastructure, search harness) is released to enable reproducible research on executable AI4AI toward RSI.

Introduction and Theoretical Foundation

Recursive self-improvement (RSI) is the ambitious goal where AI systems improve the very process that builds their successors. The paper operationalizes this within Machine Learning Engineering (MLE)—a concrete, executable testbed where an agent must construct and iteratively improve ML solutions through execution feedback.

The work is positioned at the level of meta-evolution: the improver (the model) itself is trained using evolutionary trajectories, creating a coupling between learning and evolution. Prior work advances MLE agents along three strands—inference-time harnesses, executable environments, and post-training from execution feedback—but no system jointly spans scalable task construction, execution-grounded post-training, and evolutionary search with released artifacts.

Key problem formulation: Given a task $\tau$ with specification, data, evaluator, and sandbox, the inference-time algorithm selects an operator $a_t$ and constructs context $c_t$ from parent programs. The model proposes $p_t \sim g_\theta(\cdot | \tau, a_t, c_t)$ and receives score $s_t = R_\tau(\mathcal{E}(p_t, \tau))$. Meta-evolution optimizes

$$\mathcal{L}_{\text{evo}}(\theta) = -\mathbb{E}_{(\tau_i, a_i, c_i, p_i)} \left[ w(s_i) \log g_\theta(p_i | \tau_i, a_i, c_i) \right]$$

where $s_i = R_{\tau_i}(\mathcal{E}(p_i, \tau_i))$ and $w(s_i)$ converts execution outcome into a learning weight.

Methodology

OpenMLE-Gym: Scalable Verifiable Environments

• Constructs 5,758 quality-gated executable tasks from three sources: Curated Anchors (156), Kaggle Datasets (3,362), Kaggle Competitions (2,240).
• Each task has a standardized package (public data, private answers, executable metric) and a sandbox execution backend with six feedback modes (success, runtime error, timeout, etc.).
• Covers 8 modalities (tabular 44%, image 18%, time series 13%, etc.) and 6 task types (classification 56%, regression 31%, etc.).

OpenMLE-ERL: Reinforcing Reusable Evolutionary Operators

Four atomic operators trained via:

1. Execution-grounded SFT warm-start: Budget-adaptive collection stops at quota or budget exhaustion. Parallel path (Draft solutions) and evolutionary path (Improve/Debug/Crossover on trajectory steps) produce a 26,259-example corpus.
2. Execution-grounded RL: Uses adaptive reward bounds and entropic advantage to concentrate learning on the upper tail. The reward normalization:

$$r_{\text{base}}(\tilde{s}; b_{\text{best}}, b_{\text{worst}}) = \text{clip}\left( \frac{\tilde{s} - b_{\text{worst}}}{b_{\text{best}} - b_{\text{worst}}}, 0, 1 \right)^\alpha$$

with adaptive bounds derived from each task's historical on-policy score frontier. The entropic advantage:

$$A_{\text{ent}}^i \approx \frac{\exp(\beta r_{\text{proc}, i})}{\frac{1}{G-1} \sum_{j \neq i} \exp(\beta r_{\text{proc}, j})} - 1$$

amplifies reward gaps near the top of each rollout group. Parent selection uses a three-factor utility:

$$F(p) = \text{norm}(R_p) + \text{norm}(\text{Var}_{c \in \text{child}(p)} R_c) + \text{norm}(C_p)$$

combining parent reward, child-reward variance, and visit cooling.

OpenMLE-Evo: Experience-Driven Long-Horizon Search

• Structured Experience Accumulation: Node-level experience cards (provenance, performance, execution outcome) and a task-global experience board.
• Experience-Guided Parent Selection: Three-factor utility:

$$U_i = \lambda_s \tilde{s}_i + \lambda_\Delta e^{\Delta_i} + \lambda_n \nu_i, \quad P(i | \mathcal{I}) = \frac{\exp(U_i / \tau)}{\sum_{j \in \mathcal{I}} \exp(U_j / \tau)}$$

where $\tilde{s}_i$ is normalized score, $e^{\Delta_i}$ is improvement over parent, and $\nu_i$ is method-family novelty.

• Operation-Triggered Memory Synthesis: Defers LLM-based summarization until an operator selects a node; synthesizes bounded context from ancestors, siblings, and error-related attempts.
• Operator-Conditioned Context Construction: Provides operator-specific retrieval sets (e.g., siblings for Improve, both parents for Crossover, error-matched attempts for Debug).

Empirical Validation / Results

Primary Results on MLE-Bench Lite

Under a fixed 12-hour per-task budget on one RTX 4090 (12 GB VRAM):

Table 1 | MLE-Bench Lite results (selected rows)

Key findings:

• Training gain: +21.22 pp Medal Average (39.39% → 60.61%) under same OpenMLE-Evo harness.
• Search gain: OpenMLE-Evo outperforms Claude Code and Codex across four frontier models.
• System gain: Frontis-MA1-35B + OpenMLE-Evo-Max reaches 71.21%, exceeding GPT-5.5+Codex (68.18%).
• Cross-model replication: Frontis-MA1-30B improves 34.85% → 53.03% (same pattern).

Transfer to NatureBench Lite

Table 2 | Results on NatureBench Lite (10 tasks)

• Model swap: Match-SOTA 50% → 70% (gains from post-training).
• Framework swap: Match-SOTA 20% → 50% (gains from search adaptation).
• Combined system matches GPT-5.4, GLM-5.1, MiniMax-M3 on this subset.

Mechanism Analysis

• Search efficiency: OpenMLE-Evo reduces prompt tokens by 50.3% and model tokens by 41.7% vs. original AIRA-Evo, while increasing new-best updates per million tokens by 84.3%.
• Long-horizon improvement: Later Improve and Crossover operations produce 85–92% of total validation gain in case studies, demonstrating sustained improvement beyond initial solutions.
• Parent selection impact: Three-factor selection increases probability of selecting a complementary parent from 10.47% to 17.09% in a controlled case study, enabling better held-out performance.

Theoretical and Practical Implications

Theoretical contributions:

• Introduces a meta-evolutionary framework where the same program-transformation operators are trained via execution-grounded SFT/RL and then composed into long-horizon search, creating a learnable coupling between model improvement and inference-time evolution.
• Demonstrates that training and search gains are additive and transfer across benchmarks (MLE-Bench → NatureBench), suggesting that learning to improve via executable feedback generalizes beyond training distribution.
• Shows that bounded, operation-conditioned context and multi-factor selection (quality, progress, novelty) improve search yield per token, providing a concrete mechanism for more efficient test-time scaling.

Practical implications:

• Provides a reproducible full-stack infrastructure for AI4AI research, including 5,758 verifiable tasks, training data, sandbox execution, and search harness.
• Achieves competitive performance on MLE-Bench Lite with limited compute (12h per task on single RTX 4090), approaching frontier models like GPT-5.6 Sol and Kimi K3.
• The transfer to scientific AutoResearch (NatureBench) suggests practical applicability beyond competition-style ML engineering.
• Released artifacts enable broader study of executable AI4AI and RSI.

Conclusion

OpenMLE provides an open, reproducible pathway from executable environments to post-trained models and long-horizon evolutionary search for machine learning engineering. The system demonstrates that model learning and search provide complementary gains: Frontis-MA1-35B improves Medal Average from 39.39% to 60.61% through training alone, and to 71.21% with enhanced search, exceeding GPT-5.5+Codex. Transfer evidence on NatureBench Lite shows both components generalize beyond training tasks.

The work establishes a concrete testbed for meta-evolution—the level where the improver itself is trained—as a step toward recursive self-improvement. However, the paper acknowledges limitations: richer objectives beyond final scores, integration with general coding agents, broader participation in AI development, evolving the evolutionary system itself, and richer use of recorded experience. Future work should address these to move closer to autonomous RSI.