MLExpert: Towards a Generalist Agentic Model for Autonomous Machine Learning Engineering

AI summary

Overview

Research area: Autonomous machine learning engineering (MLE) with large language model agents; specifically post-training (SFT + reinforcement learning) of a generalist agentic model for long-horizon experimentation.

Technical level: Advanced. The paper assumes familiarity with agentic tool-use loops, supervised fine-tuning, PPO-style policy-gradient methods, and group-relative RL (GRPO).

Scope in one sentence: The paper describes how a 35B Mixture-of-Experts model, MLExpert, is post-trained with hierarchical agentic SFT and a new "Windowed Interaction RL" method so that it can autonomously run and improve machine learning experiments, and reports gains on MLE-Bench Lite, NatureBench Lite, agent scaffold optimization, and algorithm-component optimization.

What This Paper Is About

Most automated machine learning systems rely on hand-designed workflows or search rules that decide what the model does next, with the LLM mainly writing code at fixed steps. This paper instead trains a model to decide for itself when to analyze, revise, execute, backtrack, or change optimization direction, using feedback from real experiments. The core problem is that such long runs contain many costly experiments, each returning delayed and entangled feedback about several earlier decisions, so the authors need a way to extract useful training signal from long interaction trajectories before a run even finishes.

Key Contributions

1. MLExpert, a 35B Mixture-of-Experts agentic model for autonomous MLE, trained with a two-stage hierarchical agentic SFT followed by Windowed Interaction RL (WIRL). WIRL groups the multi-turn decisions between successive experiment results into an "execution window" and assigns that window a single shared outcome-based reward, combined with local progress rewards and token-level policy correction for asynchronous collection.
2. Kaggle-MLE Factory, a multi-agent pipeline (discovery, analyzer, generator, executor, validator agents) that converts historical Kaggle competitions into executable tasks with a public workspace, a hidden test split, and a unified evaluator, plus manual review before trajectory collection.
3. An Interaction Harness that supports model-directed long-horizon experimentation: an experiment tree of solution nodes, tools for analysis, code revision, execution, history retrieval, plan maintenance, candidate invalidation, and submission management, with context compaction as history grows.
4. Empirical evidence that a 35B model trained this way raises average medal rate on MLE-Bench Lite from 37.9% to 72.7%, improves NatureBench Lite, and transfers to agent scaffold and algorithm-component optimization.

Main Findings

• MLE-Bench Lite improvement: Under the unified MLExpert Harness, MLExpert raises the average medal rate of its base model (Qwen3.6-35B-A3B) from 37.9% to 72.7%. Its full MLE-Bench Lite profile is Med+ 84.8, Gold 50.0, Silver 16.7, Bronze 6.1, Any Medal 72.7 (percentages over 22 tasks).
• Comparable to larger frontier models on medal rate: 72.7% matches GLM-5.3 (72.7%) and Kimi-K3 (72.7%) in the same harness. GPT-5.6 Sol reaches 77.3%, GPT-5.5 xhigh 72.7%, MiniMax M3 68.2%, DeepSeek-V4-Pro Preview 63.6%. Among same-scale baselines, Nex-N2.5-mini reaches 47.0%, Ornith-1.5-35B-A3B 39.4%, and the base Qwen3.6-35B-A3B 37.9%.
• Gains persist under a general-purpose harness: With Claude Code, MLExpert achieves 69.7% medal rate versus 42.4% for its base model, and exceeds the strongest evaluated same-scale baseline by 22.7 percentage points.
• NatureBench Lite: With Claude Code, MLExpert raises Surpass-SOTA from 0.0% (0/10) to 50.0% (5/10) and Match-SOTA from 40.0% (4/10) to 70.0% (7/10). GLM-5.3 also reaches 50.0% Surpass-SOTA; Kimi-K3 reaches 70.0%.
• Each training stage adds value (MLExpert Harness): Base 37.9 → + General Agent SFT 47.0 → + MLE SFT 62.1 → + WIRL 72.7.
• WIRL beats standard RL baselines from the same MLE-SFT initialization: GRPO 56.1%, PPO-style 60.6% — both below the 62.1% of MLE-SFT — while WIRL without trend reward reaches 66.7%, WIRL without policy correction 65.2%, and full WIRL 72.7%.
• Long-horizon behavior case study (MLSP 2013 Birds): MLExpert improves ROC-AUC from 0.58 to 0.964, compared with 0.60 to 0.88 for MLExpert-SFT, moving from audio features and LightGBM through PANNs representations to AST fine-tuning with attention pooling and an MLP head, then schedule adjustments and snapshot averaging.
• Agent scaffold optimization (AIME 2025, GPT-4.1-nano solver): The scaffold optimized by MLExpert reaches 43.7% held-out accuracy versus 23.3% for the base model's scaffold (MLExpert-SFT 38.1%, Kimi-K3 40.0%, GLM-5.3 48.1%), using 8.40 calls on average. Dev accuracy: MLExpert 46.7, base 28.9.
• Algorithm-component optimization (MLS-Bench-Lite): Across 12 selected tasks and 12 domains under a five-hour budget, mean verifier reward rises from 0.322 to 0.425, with improvement on ten tasks, a tie on one, and a lower score on one.
• Asynchronous collection efficiency: The authors report (in the appendix, referenced as Appendix 10) that asynchronous execution-window collection reduces the learner waiting fraction compared with trajectory-based GRPO.

Methodology in Plain English

The authors break the problem into three pieces.

Building tasks. Historical Kaggle competitions are messy in format, so a pipeline of specialized agents turns them into runnable tasks. A discovery agent screens competitions (completion status, at least 50 participating teams, a 200 GB dataset-size default limit, submission-interface compatibility, and an exclusion list), drawing on a Meta-Kaggle metadata snapshot with 11,649 entries. An analyzer agent extracts data structure and modality; a generator agent builds data splits and scoring code, creating a held-out test set with hidden labels when test labels are unavailable; a validator agent checks structure, formats, labels, train–test identifier overlap, and that the scorer actually returns a score, sending errors back for repair. Human review of 160 registered tasks excluded six, leaving 154.

Letting the model drive. The harness is a ReAct-style loop. Candidate solutions live as nodes in an experiment tree with parent links, so the model can revisit and compare. The model launches runs with execute_code, writes or patches code, retrieves history, maintains a plan, delegates analysis to a sub-agent with its own context, flags untrustworthy candidates with invalidate_node, and keeps a submission candidate updated. Nothing external dictates the search order.

Teaching the model, in two layers. First, hierarchical SFT: stage one uses general coding and tool-use trajectories to install basic tool use and code revision; stage two uses MLE teacher trajectories (from GLM-5.2) and scientific trajectories from 164 Nature-family papers (from GLM-5.2 and Qwen3.8-Max) to teach algorithm design, experimental analysis, and iterative optimization. Supervision is filtered by outcome: trajectories whose best leaderboard standing falls below η = 0.4 are dropped, and if performance degrades after the peak by more than a threshold δ, the trajectory is cut back to the first best-performing submission, plus a random extension of up to ten complete tool interactions. Loss is applied only to newly generated tokens, not to tool feedback or inherited history. The retained corpus is 636 trajectories (412 MLE covering 236 tasks; 224 scientific covering 77 tasks), yielding 5,539 input records and, after packing, 1,173 sequences of mean length about 257,843 tokens (roughly 302.45 million tokens) trained over eight epochs.

Learning from its own experiments. WIRL treats each completed experiment as a window boundary. The window containing the decisions that led to that result gets one reward: −1.0 for an execution error caused by the model, −0.6 for no scorable submission, −0.4 plus a trend term below the medal threshold, 1.0 plus trend for bronze or silver, 2.0 plus trend for gold, where the trend term is −0.2, 0, or +0.2 depending on whether the score fell, stayed flat, or improved relative to the previous valid submission. Unlike GRPO, the reward is used directly as the advantage with no group normalization. Because experiments take wildly different times, windows are collected asynchronously, so a trajectory can span several policy updates; the authors therefore apply token-level importance correction using stored log-probabilities, clipping out tokens outside a [q_min, q_max] band. The loss is PPO-style per token, normalized per window by valid token count, with KL regularization to a fixed SFT reference model and an entropy term.

Evaluation setup. Tasks allow up to 3,000 interaction steps and 12 hours of runtime, with 20 vCPUs, 220 GB RAM, and one NVIDIA H200 GPU. Training tasks overlapping MLE-Bench or NatureBench are excluded.

Why This Matters

The paper treats long-horizon optimization decision making — not just code writing — as a trainable capability, and shows a mid-sized model can be brought near frontier-model performance on a real MLE benchmark. For research on AI4AI and recursive self-improvement, it offers a concrete recipe for learning from delayed, entangled execution feedback rather than relying on hand-built search logic.

Real-world applications implied by the work (not themselves evaluated in the paper):

• Faster prototyping of ML pipelines for tabular, vision, text, audio, and time-series problems, using the Kaggle-MLE Factory style task packaging.
• Scientific replication and improvement, since the model matched or surpassed published results on a portion of NatureBench Lite tasks.
• Automatic design of agent workflows and scaffolds, as shown in the AIME scaffold optimization experiment.
• Optimization of individual algorithmic components inside existing research pipelines, as shown on MLS-Bench-Lite.

Industry relevance: teams with expensive compute and scarce ML engineering time could route repetitive experiment loops to an agent that decides what to try next; the paper's cost framing (12-hour budgets, H200 GPUs, thousands of steps) makes clear where the economics sit. The engineering details — executable task factories, harness design, asynchronous window-level RL — are directly reusable by anyone building agentic training infrastructure.

Future Directions

• Scaling the model: all results use a 35B MoE model initialized from Qwen3.6-35B-A3B; whether the same post-training recipe improves larger backbones, or whether WIRL's window-level reward is what closes the gap to frontier models, is untested here.
• Broadening the task distribution: training used 154 factory tasks plus 134 MLE-Dojo tasks and 164 paper-derived scientific tasks, but evaluation centers on a 22-task Lite subset and a ten-task NatureBench Lite subset. Behavior on the full benchmarks and on longer or messier competitions is not reported.
• Reward and window design: the reward uses fixed constants (−1.0, −0.6, −0.4, 1.0, 2.0) and a three-level trend term (−0.2, 0, 0.2). The paper ablates the trend term and policy correction, but not the individual reward constants or alternative window granularities.
• Sustained self-improvement: the framing points toward recursive self-improvement, yet the reported evidence is single-round post-training. Whether the model can keep improving its own training pipeline across iterations, and how to detect and prevent reward hacking or validation leakage in that setting, remains open.

Target Audience

Researchers and engineers working on agentic LLM post-training, RL for multi-turn tool use, or automated machine learning systems. It is most useful to readers who already understand SFT/RL pipelines and want concrete design choices for handling long-horizon, delayed-reward environments. Practitioners building internal ML-automation platforms will find the harness and task-factory descriptions actionable; readers new to RL fine-tuning will need background reading first.

Authors’ abstract

Large language models (LLMs) are expanding from assisting scientific research and engineering to autonomously developing and improving AI systems, advancing AI for AI (AI4AI) as a pathway toward recursive self-improvement (RSI). Workflow-driven machine learning engineering (MLE) systems provide a practical path toward this pursuit through complex orchestration that manages long-horizon experimentation, while recent MLE systems adopt model-directed interaction, allowing models to autonomously organize experiments and adapt optimization strategies based on execution feedback. However, feedback from each experiment reflects several preceding decisions, and a long MLE run contains many such costly experiments. Training must therefore select useful supervision from long interaction trajectories and learn from intermediate outcomes. We propose a post-training method for autonomous long-horizon MLE optimization and apply it to train MLExpert, a 35B Mixture-of-Experts agentic model. We design the Kaggle-MLE Factory to construct executable tasks and an interaction harness for model-directed experimentation. Hierarchical agentic SFT transfers general tool-use and coding capabilities to MLE through outcome-guided supervision. Windowed Interaction RL (WIRL) treats the multi-turn decisions between successive experiment results as an execution window and assigns it a shared outcome-based reward. Asynchronous collection and policy correction support policy updates before the trajectory ends. On MLE-Bench Lite, MLExpert improves the average medal rate of the base model from 37.9% to 72.7%, achieving performance comparable to larger frontier models such as Kimi-K3 and GLM-5.3. Further experiments show that MLExpert improves performance on NatureBench Lite, agent scaffold optimization, and algorithm optimization, suggesting that the learned optimization capability generalizes to other tasks.