ERB: AI Agents Build Their Own Model Tests and Match the Reference Benchmarks in 75% of Pairs

Recursive self-improvement in AI runs into a mundane problem: to tell whether a model has gotten better, you have to run it through heavy benchmarks, which is expensive and slows iteration. People usually get around this by taking a subset of tasks or assembling a compact set. The researchers asked whether an agent can do this on its own, and built EvalResearchBench (ERB) to find out. The best evaluators that agents created within the allotted budget order pairs of models the same way as the target benchmarks in about 75% of cases. The ceiling is set by how much the target tests agree with one another: 91%.

How an agent becomes an evaluation researcher

In ERB, the agent, which the authors call the researcher, receives the target materials, development references, a list of candidate APIs it can use, and fixed limits on time and API spend. From there it acts like an engineer responsible for test quality. It picks existing tasks or synthesizes new ones, writes graders and runs pilot trials. Based on those results, it fixes the tasks and the verification code. At the end, the evaluator is frozen as an executable program. There are three domains: coding, co-work and reasoning.

The validation is built on comparison. Nine research agents worked with 13 candidate models. Each frozen evaluator was compared against 14 target benchmarks using two metrics: consistency of the final scores, and pairwise agreement, meaning whether the evaluator and the benchmark agree on which of two models is better.

Where automation falls short

The main findings of the study:

• the best evaluators reach about 75% agreement on model pairs, against a ceiling of 91%;
• no single research agent leads on all metrics;
• the best evaluator on the target benchmarks available during development is not the best on the sealed ones, which the agent never saw;
• a human-picked sample of public tasks remains a strong baseline;
• the evaluator with the lowest recorded execution cost achieved the highest pairwise agreement.

The second finding shows the classic problem of overfitting to available targets. The agent sees the development targets and tunes the evaluator to them, but on hidden benchmarks the advantage disappears. The last finding is counterintuitive: more compute spent on evaluation does not mean more accurate model ranking. The cheap evaluator is probably simpler, fits the budget better and breaks less often along the way.

Typical failures: truncated answers, an empty budget and dominant questions

Agents can fix their own tasks and graders using feedback from pilot runs. Even so, the finished evaluators still suffer from specific defects. They can truncate model answers, in which case a correct solution is scored as wrong. They can exhaust the evaluation budget before the run finishes. Finally, they can allow a situation where a few questions determine the final score for an entire domain, and noise on a couple of tasks turns into "reasoning quality."

These errors are not exotic. Any team that has built an internal eval set has run into a max_tokens limit that cuts off an answer, or into skewed task weights. The agents reproduce familiar human mistakes, but they do it in an automated mode where no one is there to check.

Practical takeaways for teams building eval pipelines

For now, a research agent does not replace a human. It works as a draft evaluator. If you automate test selection, keep a sealed set of benchmarks that the agent never sees, otherwise picking the best evaluator becomes self-deception. A human-picked sample of public tasks should remain the control point: if an agent-built evaluator does not beat it on pairwise agreement with the target benchmarks, the automation adds nothing.

Before freezing an evaluator, it is worth adding simple checks: whether answers are truncated, whether the run fits the budget, and whether a few questions dominate a domain. Finally, treat cost as a metric: according to ERB, a cheap evaluator can rank models as well as an expensive one, or even better. For an industry where self-improving systems are bottlenecked by the price of feedback, this is a concrete reference point: 75% against 91% shows how far there still is to go before autonomous loops in which AI builds its own measuring stick.