Summary of EvalResearchBench: Can AI Agents Build Their Own Feedback for Recursive Self-Improvement?

Summary (Overview)

• Novel Benchmark Introduction: The paper introduces EvalResearchBench (ERB), a benchmark for evaluating whether AI agents can autonomously design evaluation protocols—selecting/synthesizing tasks, implementing graders, and revising them under fixed time and API budgets—to reproduce complex target benchmark scores.

• Key Finding on Agreement Ceiling: The best agent-designed evaluators achieve ~75% pairwise agreement (PA) with target benchmarks, well below the 91% ceiling set by disagreements among the target benchmarks themselves.

• No Dominant Researcher: No single researcher configuration leads across all domains (coding, co-work, reasoning); the best evaluator on development-visible targets is not the best on sealed targets, indicating limited transfer.

• Cost-Efficiency Insight: The evaluator with the lowest recorded execution cost (Grok 4.7) attains the highest pairwise agreement, demonstrating that cheap evaluation can preserve measurement quality.

• Strong Human Baseline: A human-designed public-task sampling baseline (Random120) remains competitive, with 7 of 8 agent-designed evaluators exceeding it in Score but only 4 exceeding it in PA.

Introduction and Theoretical Foundation

Background and Motivation

Recursive self-improvement (RSI) fundamentally depends on evaluation feedback to determine whether changes improve a system. However, repeatedly running complex benchmarks incurs substantial API and compute costs, creating a bottleneck for autonomous improvement loops. Human experts mitigate this by selecting representative benchmark subsets or designing compact proxies (e.g., tinyBenchmarks).

Key Gap

Prior work falls into two categories:

1. Automated improvement with fixed evaluation: Systems like PostTrain-Bench, RSIBench-Data, and AlphaEvolve automate improvement but rely on human-supplied evaluation protocols.
2. Automated evaluation design components: PACE, AutoBencher, and BenchBench automate parts of evaluation design but don't pose the full research problem.

The paper asks: Can an agent with fixed time and API budgets build an evaluator that reproduces how complex target benchmarks score and rank models?

Theoretical Foundation

The evaluation framework is built on two agreement metrics:

Score (100 times Lin's concordance correlation coefficient, CCC):

$$\mathrm{Score}_{a,t} = 100 \cdot \frac{2\operatorname{Cov}(x,y)}{\operatorname{Var}(x) + \operatorname{Var}(y) + (\bar{x} - \bar{y})^2}$$

Pairwise Agreement (PA) for non-tied reference pairs $\mathcal{P}_t = \{(i,j) : i < j, y_{i,t} \neq y_{j,t}\}$:

$$\mathrm{PA}_t = \frac{1}{|\mathcal{P}_t|} \sum_{(i,j) \in \mathcal{P}_t} \left[\mathbf{1}\{(x_{i,d} - x_{j,d})(y_{i,t} - y_{j,t}) > 0\} + \frac{1}{2}\mathbf{1}\{x_{i,d} = x_{j,d}\}\right]$$

The measured score for candidate $m$, domain $d$, by researcher $a$ is:

$$x_{a,m,d} = \frac{\sum_{i \in C_{a,m,d}} w_{a,i} s_{a,m,i}}{\sum_{i \in C_{a,m,d}} w_{a,i}}$$

Methodology

Research Task Design

Three roles defined:

• Researcher: An LLM agent with a harness for file inspection, code execution, model calling, and iterative revision
• Candidate: A model–execution configuration whose capabilities must be measured
• Target benchmark: An established evaluation providing reference scores to reproduce

Three domains covered:

1. Coding: Repository engineering, scientific programming, terminal workflows
2. Co-work: Information gathering, constraint following, professional deliverables
3. Reasoning: Academic questions, long documents, specialized physics

Budgets and Constraints

Submission Requirements

• At least 100 distinct scored questions
• Executable graders and fixed aggregation rules
• One score per domain returned from frozen assets
• No candidate-identity lookup or reference-label access during scoring

Experimental Setup

• 9 researcher configurations: GPT-6 Astra, GPT-5.6 Sol, GLM-5.3, DeepSeek V4 Pro, Kimi K3, Fable 5.1, Opus 5, Grok 4.7, Fable 5
• 13 candidates: 4 development-visible, 9 sealed
• 14 target benchmarks: 6 development-visible, 8 sealed
• Harnesses: Codex (GPT researchers, Grok), Claude Code (others)

Baseline: Random120

A source-stratified baseline sampling 40 coding, 40 co-work, and 40 reasoning tasks from 16 public sources with fixed quotas, local graders, and equal item weighting—without using target reference scores.

Empirical Validation / Results

Main Results (Table 2, key rows)

Key Findings

1. Domain strengths vary: Grok 4.7 leads coding, Astra leads co-work, Opus 5 leads reasoning; coding is the weakest domain for most evaluators.

2. Development vs. sealed transfer failure: Fable 5.1 leads development Score but Grok leads sealed Score—fitting visible references doesn't ensure transfer.

3. Random120 baseline strength: Seven of eight agent-designed evaluators exceed it in Score, but only four exceed it in PA.

4. Weight allocation problems: Recomputing Grok's scores with equal item weights substantially improves coding and co-work Score while overall PA barely changes—the frozen suite contains useful signal that its chosen weights underuse.

5. More questions improve consistency: Mean Score rises and both Score and PA fluctuate less across question draws as subsets grow (Figure 4c–f).

6. Cost-quality tradeoff: Grok combines low assessment cost with the highest overall PA and competitive Score; task count alone gives little indication of recurring cost.

Theoretical and Practical Implications

Implications for RSI Systems

• Evaluation design is a distinct capability: Autonomous improvement loops need agents that can design their own feedback instruments—this is a prerequisite for closed-loop self-improvement.

• Transfer is a key challenge: The gap between development and sealed target performance suggests that overfitting to visible references is a real risk in evaluation research.

• Cost-aware design matters: The separation of construction cost from execution cost is crucial—an evaluator built once but run repeatedly should optimize for low recurring cost.

Design Principles Emergent from Results

1. Task selection should target measurement contribution: Task realism and difficulty motivate a design, but its value depends on how it separates candidates relative to the target.

2. Answer allowances and graders shape costs: What a candidate must produce and how its answer is judged are the two distinct design choices behind execution cost.

3. Aggregation weights need joint optimization: Task contribution, sampling variability, and score aggregation must be considered jointly, not independently.

Practical Observations

• Agents can repair tasks and graders through pilot feedback, yet final evaluators can still truncate answers, exhaust evaluation budgets, or let a few heavily weighted questions dominate a domain score.
• Short expected answers don't make problems easy to solve—Grok's hard HLE pilots exhausted answer allowances despite favoring short code and numeric checks.

Conclusion

EvalResearchBench establishes an executable benchmark for the evaluation-design capability that autonomous improvement requires. The work demonstrates that:

1. Current AI agents can partially automate evaluation research, achieving up to ~75% pairwise agreement with target benchmarks, but substantial room for improvement remains.

2. The problem is multi-faceted: Score reproduction, candidate ordering, and execution cost are distinct objectives that may favor different designs.

3. Future directions include developing agents that can better balance development-fit with sealed-target transfer, optimize weight allocation to preserve measurement signal, and design cost-efficient evaluators without sacrificing quality.

The benchmark provides a foundation for studying how agents can construct feedback instruments—a critical capability for recursive self-improvement systems that must evaluate their own progress without relying on human-designed evaluation protocols.