acceptodds
Under review as a conference paper at ICLR 2027

AI4AI-Bench: Benchmarking LLM Agents in Algorithmic Design for Recursive Self-Improvement

Abstract

Recursive self-improvement (RSI) asks whether an AI system can improve the process that produces AI systems, so that the next system inherits the improvement. That process is the training algorithm: a better objective or update rule improves the compute-capability exchange rate for every subsequent run, including the one that produces the next agent. Whether RSI is feasible therefore turns on whether an agent can design training algorithms. We present AI4AI-Bench to evaluate this capability on real machine-learning tasks, giving agents broad freedom to redesign algorithms and training frameworks within fixed task constraints. The benchmark comprises 10 frozen research repositories spanning 10 algorithm families. In each task, an agent has 4 hours on one B300 to rewrite the procedure; its submitted source is then rerun from scratch for up to 12 hours and scored by a fixed evaluator against the repository's reported reference. Because the 10 metrics are incommensurable, every task is mapped onto one scale on which is an uninformative or invalid result, is the reported repository reference, and is a fixed upper normalization anchor. Across 29 configurations of 6 systems on all 10 tasks the mean score is , and the best system reaches : even the strongest closes under a fifth of the reference-to-anchor interval. Among classifiable submissions, most match only run-level categories; patches matching at least one learning-level category average , compared with for run-only matches. Higher reasoning effort is associated with more learning-level matches ( versus among classifiable submissions) and higher scores ( versus ); the pooled effort groups differ in system composition, so these comparisons do not identify a causal mechanism. We release the task suite, the evaluators and every scored submission, so that the measurement can be repeated as these systems change.

Primary area:
datasets and benchmarks
Keywords:
AI agents, recursive self-improvement, algorithmic design, automated machine learning, benchmarks

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_AcuCOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
1
Soundness
2
Read review
Paper summary

Proposes a new benchmark of 10 AI tasks (including start code and models) that AI models are tasked with improving, to test the ability of models to improve the solution.

Critical strengths

I like the overall idea of creating benchmarks to test AI's ability to improve AI codebases and models. I also like the decision to retest the final code.

Critical weaknesses

The biggest weakness is the writing. It reads like it was almost entirely AI-generated. Even if it was not, it is incomprehensible in many places. Many sentences come out of left field and are confusing because they seem to refer to things the reader has not been told about (likely due to AI referring to past parts of the chat if AI generated). The abstract is a good example, but there are so many throughout the paper (lines 44-45, 96-98, 115-117,211,196, 233, 264 and on and on. Also, many key things are never explained.

Another huge issue is a lack of statistics. We don't know if anything is noise vs. signal, and that's especially true with the large number of experiments/comparisons.

The literature review is weak, overly dense, and doesn't even answer the most basic questions: is this new? what is similar to it?

Key methods are missing, like the prompts to the models.

The paper is also extremely repetitive.

Overall I don't learn much. Are these tasks good? Why these vs. others? Why not evaluate sustained progress vs. one-off deltas? Is the point to eval models out of the box for their ability to improve AI, or to test their ability to improve over time (seems more important), or to evaluate self-improvement algos? Do the results tell us about the benchmark vs prior benchmarks (no), so what do they tell us? About the models? If so, is the paper about testing the models or creating a benchmark?

More minor things:

  • I think you should reference the literature more, including open-ended and AI-generating algorithms including things like the Darwin Godel Machine, HyperAgents, the Automated Design of Agentic Systems, etc.
  • font is way too small in Fig 1
Questions for authors
  • did you look for reward hacks?
  • is this entirely new? what are other similar attempts?
  • is it fair to average over all these different effort levels for different models?
  • what does it mean that the agent can change the objective?
  • how do you know the results are signal and not noise? What would be the proper stats to do to show that, especially given the multiple comparisons
  • what's the real point here? to eval models out of the box for their ability to do one delta? what about sustained improvement over time by building on their discoveries? What about open-ended improvement algos like DGM/hyperagents? should they be tested included?
Reviewer_ri3XOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces AI4AI-Bench, a benchmark for evaluating LLM agents that improve existing machine-learning research procedures. The suite contains ten frozen repositories covering ten algorithm families. Agents receive four hours on one B300 GPU to explore and modify the code, after which their submitted source is rerun from a fixed starting point in a fresh container for up to twelve hours. The paper evaluates 29 model–harness–effort configurations, reports raw and normalized task scores, and analyzes submitted patches using fixed lexical rules.

Critical strengths
  1. The source-submission and independent-replay protocol is useful. Separating exploration from formal execution tests whether agents can encode their improvements in a procedure that can be rerun, rather than only produce a favorable checkpoint during development. This helps assess the completeness and executability of submitted solutions.

  2. The task coverage and result reporting are substantial. The suite spans supervised fine-tuning, reinforcement learning, distillation, reward modeling, unlearning, graph diffusion, weight averaging, and pruning. Tables 2 and 4 report the complete normalized and raw-score grids, allowing readers to inspect task-specific gains and failures rather than relying only on aggregate rankings.

  3. The behavioral analysis and concrete examples help explain agent behavior. Section 4 distinguishes run-level from learning-level changes and provides examples involving pruning, weight averaging, and agentic RL. The authors also clearly acknowledge that lexical matches do not establish execution, algorithmic novelty, or causality, and that the experiments do not demonstrate recursive improvement over successive generations.

Critical weaknesses
  1. The incremental contribution relative to existing RSI-related benchmarks could be made more concrete. RSIBench-Data studies feedback-driven training-data research under a fixed post-training stack, while DiscoGen/DiscoBench addresses algorithm discovery through editable modules and held-out meta-test evaluation. Sections 1 and 5 correctly distinguish these settings from AI4AI-Bench's open repository-level editing and clean replay. However, the practical significance of this combination is less developed than the description of its protocol. Section 4.3 provides useful examples, but does not clearly connect them to the proposed setting's advantages over more structured evaluation. Explaining which aspects of these cases depend on repository-level freedom, and what is gained or lost relative to controlled component-level benchmarks, would strengthen the case for this benchmark's contribution.

  2. The interpretation of high scores as evidence of algorithmic design could be clarified. Section 2 permits changes to training duration, hyperparameters, data, objectives, and the surrounding framework, so the final score reflects the effectiveness of the complete submitted procedure. The paper appropriately treats the learning-level versus run-only comparison in Section 4.1 as observational. However, it remains difficult to assess how much of the measured improvement requires changes to the learning procedure rather than tuning or more effective use of the available compute. A focused comparison on representative tasks, such as a runtime- and hyperparameter-only variant or an original recipe rerun under the candidate budget and checkpoint-selection rule, would help calibrate this interpretation. Such an analysis would strengthen the benchmark's algorithmic-design framing without requiring a causal decomposition of every submission.

  3. Some final scores do not separate gains on development-visible examples from gains on strictly held-out examples. Appendix A states that BTRM’s final evaluation includes 512 visible proxy pairs, DPO includes 128 visible prompts out of 413, and Model Soup includes 2,000 proxy images out of 10,000. These overlaps are disclosed, but repeated proxy queries may favor procedures adapted to those examples. Full-set scores cannot distinguish this adaptation from improvement on unseen examples. Independent replay verifies performance after rerunning the procedure, but does not resolve this generalization question. Reporting the visible and strictly held-out subsets separately would make the improvements easier to interpret.

Questions for authors
  1. Which findings demonstrate the added value of repository-level editing and independent replay over RSIBench-Data and DiscoGen/DiscoBench?

  2. For BTRM, DPO, and Model Soup, do the improvements over the references persist when evaluated only on the strictly held-out subsets?

Reviewer_s2xpOpenReview ↗
Rating
2
Confidence
1
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper frames recursive self-improvement as the question of whether agents can improve the training algorithms that produce AI systems, and introduces AI4AI-Bench to measure this on frozen research repositories spanning diverse algorithm families (e.g., SFT, RL, preference optimization, unlearning, pruning, merging). Agents may freely redesign the training procedure but submit only source code, which is re-run from scratch and scored by an isolated evaluator, so the benchmark evaluates a reproducible algorithm rather than a selected checkpoint. Heterogeneous metrics are mapped to a common scale anchored at the repository reference, and submissions are further categorized into run-level versus learning-level changes to analyze what kinds of improvements agents actually make.

Critical strengths

The paper frames recursive self-improvement as the question of whether agents can improve the training algorithms that produce AI systems, and introduces AI4AI-Bench to measure this on frozen research repositories spanning diverse algorithm families (e.g., SFT, RL, preference optimization, unlearning, pruning, merging). Agents may freely redesign the training procedure but submit only source code, which is re-run from scratch and scored by an isolated evaluator, so the benchmark evaluates a reproducible algorithm rather than a selected checkpoint. Heterogeneous metrics are mapped to a common scale anchored at the repository reference, and submissions are further categorized into run-level versus learning-level changes to analyze what kinds of improvements agents actually make.

Critical weaknesses
  • Most of the aggregate gain over the reference appears to come from two tasks (RAGEN and OWL), where submissions add training or supervision with far more compute than the reference used. Reference scores under the same budget and checkpoint rule, plus a leave-one-task-out aggregate, would show how much reflects algorithmic design rather than compute.
  • Each configuration-task pair is a single run, and some results swing sharply across effort levels, so the rankings and effort trends remain uncertain. A few repeated runs and a manually validated version of the run-level vs. learning-level classifier would strengthen the conclusions."
Questions for authors
  1. What do the reference pipelines score when given the same budget and checkpoint-selection rule as the agent submissions?
  2. Do the system ranking and the learning-level vs. run-level gap hold after removing RAGEN and OWL, or under repeated runs?
  3. How were the normalization anchors chosen (e.g., for DDPO), and were high-scoring outputs inspected for reward over-optimization?"

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.