Navers lab
← Research
Benchmark

AI4AI-Bench

Can a coding agent improve the training method an AI project already uses?

Most agents tune the settings around the existing method. Few rewrite the method itself — and that is where the gains turn out to be.

Navers Lab · Einsia.AI · 2026

Loading…

0.10 — the code already in the repository deeper colour = the agent was told to think harder
One group per model, one bar per reasoning-effort level, joined so the effort ladder is visible; deeper colour is more effort. Each bar is that configuration's mean score over the ten tasks, labelled with the score and with what its four hours of exploration cost. The dashed line at 0.10 is the algorithm each repository already ships. Pick a task to see the same configurations on that task alone.
One bar = one agent at one thinking level

Six agents, most of them run at several settings.

Dashed line = the code already in the repository

Matching it scores 0.10; below it, the rewrite made things worse.

1.0 = a perfect result on the task

Nothing here comes close. That is the finding.

Across all 290 runs the average is 0.166 — just above the code that was already there. Claude Opus 5 leads at 0.250, GPT-5.6 Luna trails at 0.117, and in 124 runs the rewrite was worse than what it replaced. Exploration cost $5334 in all, from $4 to $626 per configuration — and the most expensive one is not the best.

What we did

Ten frozen research projects, one instruction

Each task is a working research codebase — the repository behind a paper, with the training code its authors actually ran. The agent gets that repository and the model its training starts from, and one instruction: make this project's own training method better. The ten cover deliberately different ground, so no single trick carries an agent through.

The ten tasks: for each, what the repository trains, what the agent is handed, and the metric it is finally scored on.
One card per task: what is being trained, what the agent starts from, and the held-out measurement that scores it.
Open the task gallery →

The rules

The agent writes the code; a sealed pipeline trains it and scores it

An idea can be judged in minutes, but settling it takes a full training run — so the two are split. Without that separation a high score could just mean the agent watched a run and stopped it at a lucky moment.

The agent · 4 hours · 1 GPU

Repository + model

A real research codebase, its training code, and the model that training starts from.

Rewrite and probe

The agent edits the training code and runs its own short experiments against a cheap proxy metric.

process killed
source code only

Sealed · up to 12 hours

Train from scratch

The submitted code trains a model for up to 12 hours in a container the agent cannot reach.

Held-out test

A test the agent never saw scores the model — and scores the original code the same way.

The score

How ten tasks end up on one axis

Picture quality, perplexity and puzzle solve rates cannot be averaged, and counting wins hides by how much. Each task is placed on the same 0-to-1 axis by three fixed marks.

0Knowing nothingA model that learned nothing useful.
0.1The original codeThe project's own method, same conditions.
1.0PerfectEvery problem solved, nothing left to predict.

Above 0.1 the score says how much of the remaining distance was closed. An agent that returned nothing runnable scores 0, so giving up early is never rewarded.

Why it matters

This is the part of “AI improving AI” that compounds

An agent could speed up the hardware, find better data, or improve the training method. The first two pay once. A better method is inherited by every model trained afterwards — including the one that becomes the next agent. Existing benchmarks are won by assembling data or searching over settings, and cannot tell a redesigned method from a tuned one. This one is built to.

What the agents changed

Most tuned the run. Few changed how the model learns.

A score says whether a rewrite worked, not what it did — so we read the submitted code too. Of the 263 submissions that changed anything, the changes fall into two kinds: adjusting how a run is operated (length, checkpoints, learning rate, batch size), or changing how the model learns (the objective, the supervision, the update rule, the data).

54%141 of 263 only adjusted the run

Careful engineering, original method untouched.

average score 0.126
46%122 of 263 changed how the model learns

A new objective, new supervision, a different update rule, or different data.

average score 0.226

The harder kind of change scores nearly twice as well, and more than half the submissions never attempt it.

What more reasoning buys

More reasoning buys nerve, not results

Every agent here can be told how much to reason before it acts. Turned up, they attempt the harder kind of change far more often: the share that touches how the model learns rises from 8% at the lowest reasoning setting to 64% at the highest. What comes back improves much less — the average score moves from 0.094 to 0.196, and no agent improves steadily as the setting rises. Every one of them peaks somewhere in the middle and falls back.

Citation

@article{ai4aibench2026,
  title  = {AI4AI-Bench: Benchmarking LLM Agents in Algorithmic Design
            for Recursive Self-Improvement},
  author = {Navers Lab and Einsia.AI},
  year   = {2026},
  note   = {Benchmark release}
}

Placeholder entry; the arXiv record replaces it on publication.