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

> AI4AI-Bench shows LLM agents rarely improve training algorithms, scoring 0.166 on average, yet algorithmic changes yield the largest performance gains.

- **Source:** [arXiv](https://arxiv.org/abs/2608.20318)
- **Published:** 2026-08-22
- **Permalink:** https://picx.dev/p/r7iA0U
- **Whiteboard:** https://picx.dev/p/r7iA0U/image

## Summary

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

## Summary (Overview)

- **Novel benchmark for algorithmic design**: AI4AI-Bench introduces 10 frozen research repositories spanning 10 distinct training algorithm families (SFT, agentic RL, distillation, reward modeling, preference optimization, diffusion RL, unlearning, graph diffusion, weight averaging, and pruning), designed to isolate whether agents can improve *how models learn* rather than merely *how runs execute*.

- **Key finding — agents rarely touch the algorithmic layer**: Across 29 configurations of 6 systems on 290 cells, the mean score is 0.166 on a scale where 0.1 = the repository's shipped algorithm and 1.0 = task optimum. Of 263 submissions that changed anything, 141 (53.6%) never modify the learning procedure at all—they only adjust budgets, hyperparameters, checkpointing, or capacity.

- **Algorithmic changes yield the real gains**: Submissions that reach the learning layer (loss, supervision, update rule, data) average 0.226 versus 0.126 for those that stay on the "run" side—a gap of 0.100 with standard error 0.022.

- **Reasoning effort buys "nerve," not skill**: Increasing reasoning effort raises the share of submissions touching the learning algorithm from 8% to 64% and mean score from 0.094 to 0.196, but the best configuration still only closes ~10% of the distance from baseline to optimum.

- **Resource release**: The task suite, evaluators, and all scored submissions are publicly released for reproducible measurement.

## Introduction and Theoretical Foundation

### The Recursive Self-Improvement (RSI) Question

The paper frames RSI as a question about **training algorithms**: if an AI system can improve the process that produces AI systems (the training algorithm), then the next system inherits that improvement. The key insight is that a better objective or update rule improves the "compute-capability exchange rate" for every subsequent run.

### The Gap in Existing Benchmarks

The authors argue that no existing benchmark isolates algorithmic design ability:

- **MLE-Bench / ML-Bench**: Won by feature engineering and ensembling; the learning algorithm remains an unedited library call
- **PostTrainBench**: Largest levers are data assembly and initialization, not the objective
- **RSIBench-Data**: Deliberately freezes the post-training stack so only data decisions vary
- **MLS-Bench**: Component boundaries are handed to the agent; scores conflate execution and learning changes
- **autoresearch**: Single 5-minute script runs behave like hyperparameter search, losing to CMA-ES and TPE

### The Core Distinction

> "Editing source code is therefore not the same as designing an algorithm... a hyperparameter is a number the training algorithm takes as given, an algorithmic change rewrites the algorithm—the loss it optimizes, the update it applies."

The paper analogizes to a machine learning scientist who: reads training dynamics (loss curves, gradient norms, entropy), identifies the failing mechanism (collapsed entropy, dominating penalty term), and fixes that mechanism.

## Methodology

### Task Formulation

Formally, a task is a tuple $(C, a_0, q, m, d)$ where:
- $C$ = repository source (frozen)
- $a_0$ = starting model
- $q$ = inexpensive proxy metric (available to agent)
- $m$ = final evaluation metric
- $d \in \{\uparrow, \downarrow\}$ = direction of improvement

The agent observes $(C, a_0, q)$ under exploration budget $T_e = 4$ hours on one B300 GPU and returns rewritten source $C'$. Execution under verification budget $T_v = 12$ hours yields:

$$s(C') = m(a(C'))$$

A submission improves when $s(C') \succ_d s(C)$, i.e., $s(C') > s(C)$ if $d = \uparrow$, or $s(C') < s(C)$ if $d = \downarrow$.

### The 10 Tasks

| Task | Algorithm Family | Starting Model | Evaluation Metric |
|------|-----------------|----------------|-------------------|
| OpenR1 | supervised fine-tuning | Qwen2.5-Coder-1.5B-Instruct | LiveCodeBench ↑ |
| RAGEN | multi-turn agentic RL | Qwen2.5-3B-Instruct | held-out solve rate ↑ |
| OPD | on-policy distillation | R1-Distill-Qwen-1.5B | AIME 24/25 ↑ |
| BTRM | Bradley-Terry reward model | Mistral-7B-Instruct-v0.2 | RewardBench ↑ |
| DPO | preference optimization | merged Zephyr/Mistral-7B | IFEval strict ↑ |
| DDPO | diffusion RL | Stable Diffusion v1.5 | aesthetic score ↑ |
| NPO | machine unlearning | Llama-3.2-1B-Instruct | balanced score ↑ |
| DiGress | discrete graph diffusion | QM9 graph diffusion model | test NLL ↓ |
| Model Soup† | weight averaging | 72 CLIP checkpoints | ImageNet-V2 top-1 ↑ |
| OWL† | one-shot pruning | OPT-6.7B dense | WikiText-2 perplexity ↓ |

†These two tasks do no training; they are executed once rather than trained to a horizon.

### Scoring Function

Each task is equipped with a progress coordinate $\varphi$ (strictly increasing function of quality), plus three reference points: uninformative model $x_\perp$, baseline $x_b = s(C)$, and optimum $x^*$. The score is:

$$\sigma(x) = \begin{cases} 0.1 \frac{\varphi(x) - \phi_\perp}{\phi_b - \phi_\perp}, & \varphi(x) \leq \phi_b, \\ 0.1 + 0.9 \frac{\varphi(x) - \phi_b}{\phi^* - \phi_b}, & \varphi(x) > \phi_b, \end{cases}$$

clipped to [0, 1], with $\sigma = 0$ for submissions returning no model. The scale pivots at $\sigma = 0.1$ (the shipped algorithm), with 1.0 being the task optimum.

**Key transformation**: For perplexity, $\varphi = -\log x$ (since perplexity is the exponential of cross-entropy). This matters: taking OWL from 53.4 to 16.2 reads as closing 71% of the distance linearly, but correctly only 30% in nats (removing 1.19 of 3.98 nats above a perfect predictor).

### Protocol

- **Exploration (4 hours)**: Agent reads, edits, and tests against the proxy metric freely
- **Verification (12 hours)**: Submitted source runs from initialization; three most recent checkpoints scored; best taken
- **Boundary**: The final metric is computed from source the agent can no longer touch, by an evaluator frozen before the first run

### Systems Evaluated

Six systems: GPT-5.6 variants (Sol, Terra, Luna) under Codex at all six effort levels; Claude 5 variants (Opus 5, Sonnet 5) under Claude Code at five levels; Kimi K3 under Claude Code at its highest—29 configurations × 10 tasks = 290 cells.

## Empirical Validation / Results

### Overall Performance

- **Mean score**: 0.166 across all 290 cells
- **Best system average**: 0.250 (Claude Opus 5)
- **Best single configuration**: Claude Opus 5 at medium effort, averaging 0.288
- **124 of 290 cells fall below 0.1** (worse than the repository's own algorithm)

### System Rankings (Compressed)

1. Claude Opus 5: 0.250
2. GPT-5.6 Sol: 0.191
3. Kimi K3: 0.174
4. Claude Sonnet 5: 0.145
5. GPT-5.6 Terra: 0.135
6. GPT-5.6 Luna: 0.117

The entire range sits inside the bottom quarter of the scale. Spend does not explain ordering: Opus 5 leads at median \$181, under half of what the second-placed system spent.

### What Submissions Actually Change

From Table 4 (263 classifiable submissions):

| Side | Family | n | Share |
|------|--------|---|-------|
| run | how long it trains, how often it saves | 253 | 96.2% |
| run | training hyperparameters | 195 | 74.1% |
| run | which checkpoint to keep | 105 | 39.9% |
| run | trainable capacity and where | 73 | 27.8% |
| learning | the loss it optimizes | 87 | 33.1% |
| learning | the supervision it learns from | 66 | 25.1% |
| learning | the update rule itself | 23 | 8.7% |
| learning | the data it trains on | 21 | 8.0% |
| **any learning family** | | **122** | **46.4%** |
| **run side only** | | **141** | **53.6%** |

**Key result**: Submissions touching the learning side average 0.226 vs. 0.126 for run-side-only—a gap of 0.100 (SE = 0.022). This holds when dropping agentic RL (0.182 vs. 0.128) and within four of five models.

### Reasoning Effort Effects

| Metric | Lowest effort | Highest effort |
|--------|--------------|----------------|
| Share touching learning algorithm | 8.0% | 64.0% |
| Mean score | 0.094 | 0.196 |
| Median evaluations per task | 4 | 16 |
| Median lines edited | 18 | 246 |
| Median output tokens | 11k | 109k |
| Median cost per task | \$1.69 | \$34.60 |

The score roughly doubles with effort, but 0.196 is still only a tenth of the way from shipped algorithm to optimum.

### Notable Successful Submissions

1. **OWL (pruning)**: Replaced one-shot pruning with a three-stage pipeline (new weight selection rule → layerwise distillation → masked knowledge-distillation fine-tuning with AdamW, 666 steps, cosine decay), improving perplexity from 53.4 to ~13. The agent diagnosed a bug where activation propagation overwrote layer 0's input in place.

2. **Model Soup (weight averaging)**: Built a GPU-resident instrument (0.38s per evaluation vs. ~190s), then ranked five methods: best single 0.6935, uniform 0.6880, top-k 0.6945, greedy soup 0.7025, learned coefficients 0.7020.

3. **RAGEN (agentic RL)**: Replaced GRPO with imitation learning—generate boards, label steps with optimal moves, fine-tune on supervision; one went further with DAgger.

## Theoretical and Practical Implications

### For RSI Research

The benchmark provides the first isolated measurement of the "algorithmic link" in recursive self-improvement. The finding that most agents never touch the learning procedure—even when explicitly asked to improve the training algorithm—suggests a fundamental limitation in current LLM agents' ability to perform the kind of mechanistic reasoning required for genuine algorithmic innovation.

### For Agent Design

- Reasoning effort is a "nerve" knob, not a "skill" knob: it increases willingness to attempt algorithmic changes without improving the quality of those attempts
- The most successful submissions shared a common pattern: **build something measurable before acting** (a solver to establish ceiling, a fast evaluation rig, a diagnosis of which layer was corrupted)
- This capability—reading training dynamics as specific failure mechanisms—is what the paper finds missing in most submissions

### For Benchmark Design

- The paper demonstrates the importance of separating execution-level from algorithm-level changes
- The dense scoring function (vs. binary success/failure) provides gradient for RL training of agents
- The protocol's asymmetry (4h exploration vs. 12h verification) mirrors real ML research conditions

## Conclusion

**Main takeaways**:

1. AI4AI-Bench isolates the algorithmic design level—whether agents can improve *how models learn* rather than just *how runs execute*
2. Current agents (as of the paper's date) score 0.166 on average, with the best system at 0.250—most of the distance to better algorithms remains unclosed
3. The algorithmic layer is where gains are made (0.226 vs. 0.126), yet most submissions (53.6%) never reach it
4. More reasoning effort increases willingness to attempt algorithmic changes (8% → 64%) but not the quality of those attempts

**Future directions**: The paper positions itself as an ongoing measurement instrument: "What today's agents do at the algorithmic link, then, is recover a competent default rather than design past one; whether that changes is the measurement this benchmark exists to keep taking."

---

_Markdown view of https://picx.dev/p/r7iA0U, served by PicX — AI-generated visual whiteboard summaries of research papers._