AI Agent Research Evaluation: Building a Verifiable Evaluation Framework
Can AI agents actually do research? Answering this is far harder than checking whether they can solve textbook problems. Research outputs—new constructions, tighter bounds, faster programs, or recheckable proofs—must be independently verifiable by peers, so evaluation cannot rely on simple answer matching. Drawing on a verifiable framework built around theoretical computer science problems, this article explains how to turn research tasks into a scorable, traceable, and reproducible pipeline. It covers the task pool and capability ladder, task cards and verifiers, tiered protocols that separate real ability from external scaffolding, how to read metrics and capability matrices, and practical steps for building your own evaluation on the cloud—plus the capability boundaries AI research still faces.
1. Introduction: Why Research Ability Is More Than Answering Correctly
Over the past two years, agents powered by large language models have steadily improved on math competitions, programming contests, and software engineering tasks. This has made “Can AI do research?” a shared concern across industry and academia. Yet a common misconception is to equate “being able to solve problems” with “being able to do research.”
The key difference lies in the form of the output. Solving a problem usually produces a single answer. Research, on the other hand, might produce a new mathematical object, a tighter bound, a program that runs and runs faster, or a proof that can be rechecked. These outputs must be independently verifiable by peers. So when we evaluate an AI’s research ability, we cannot only ask “Did it get the answer right?”—we must also ask “Did it produce a new result that can be verified?”
Using a verifiable evaluation framework for theoretical computer science problems as an example, this article shows how to turn research tasks into an engineering evaluation process that is scorable, traceable, and reproducible. It then discusses metric definitions, task-card design, verifier implementation, anti-contamination measures, and capability boundaries.
2. Why Traditional Evaluation Struggles to Measure Research Ability
In the era of foundation models, evaluation research has already accumulated substantial experience: once a benchmark is public, it is easily gamed; once data enters the next generation’s training set, the questions may be memorized; rising leaderboard scores do not necessarily reflect real capability gains. These problems persist in the agent era.
For research-type tasks, the difficulty is even higher, mainly in four respects:
- Open answer space: Open-ended research questions often have no single answer. “Better” is usually an optimization target relative to known results, so simply comparing answers does not work.
- Reliance on human scoring: The quality of research results often requires expert review, with inconsistent standards, long cycles, high cost, and greater difficulty in reproduction.
- Hard-to-constrain trajectories: The reasoning process is long and stochastic. Looking only at the final answer, it is hard to tell whether the ability came from autonomous reasoning or from prompt engineering, external retrieval, or human scaffolding.
- Authenticity and contamination risk coexist: Overly toy-like problems do not reflect real research, while public benchmarks face the risk of training-data contamination.
Therefore, research evaluation cannot be only “answer matching”; it needs to shift toward “artifact delivery + independent verification.”
3. Three Pillars of a Verifiable Research Evaluation
3.1 Task Pool: Real Problems, Accepted Baselines, a Capability Ladder
The first pillar of verifiable evaluation is the task pool. Tasks should be drawn from real research problems as much as possible and come with accepted baselines—for example, published best values, published upper bounds, reference constructions, or reference programs.
Common tasks fall into four categories:
- Combinatorial construction: Construct a better object under given constraints, such as an extremal graph, an error-correcting code, or a scheduling scheme.
- Bounds and proofs: Provide a tighter upper or lower bound and submit a mathematical argument that can be rechecked.
- Program optimization: Improve the performance of an algorithm or program while preserving correctness.
- Complexity conclusions: Provide better parameter values or more precise expressions around classical results.
Arranged this way, it is equivalent to designing a capability ladder for the agent: from solving a problem, to solving it and giving a proof, to constructing a new object. The agent does not need to “discover new knowledge out of thin air”; instead, it advances improvements under a clear goal and clear reference—consistent with the way real research “continues from existing literature.”
3.2 Task Cards and Verifiers: Making Outputs Independently Checkable
The second pillar is task cards and verifiers. The core principle is the separation of task declaration from verification logic: the task card specifies the problem, budget, baseline, submission format, and scoring criteria; the verifier independently checks whether the output is valid.
A task card can include task type, baseline, budget, and verification fields. For example, a combinatorial construction task can be written as:
{"task_id": "extremal-graph-girth-5","kind": "combinatorial_construction","statement": "Construct a graph with as many edges as possible that contains no triangles and no quadrilaterals","baseline": {"edges": 629,"source": "task-card:TCS-Agent-Eval-v0.9/eg5-v1.3"},"budget": {"max_turns": 200,"max_wall_time_sec": 7200},"verifier": {"type": "script","schema": "graph","checks": ["triangle_count == 0","four_cycle_count == 0"],"score": "edges","better": "higher"}}
An upper-bound proof task is different. What it submits is not an object but a proof text. The verifier may perform formal checks via a script, or be reviewed by a domain expert, but the passing condition must be explicit. For example:
{"task_id": "code-A2210-upper-bound","kind": "upper_bound_proof","statement": "Prove an upper bound for the binary code parameter A(22,10)","baseline": {"upper_bound": 84,"source": "task-card:TCS-Agent-Eval-v0.9/code2210-v1.1"},"verifier": {"submission": "proof_text","checks": ["proof_valid_by_expert","upper_bound_not_greater_than_baseline"],"better": "lower"}}
When executing verifiers, you cannot uniformly write different tasks as “score higher than baseline.” More reasonable pseudocode is as follows:
def judge(task, artifact):if task.kind == "combinatorial_construction":# Combinatorial construction: check constraints first, then compare the value against the baselinereturn Verdict(solved=artifact.constraints_ok and artifact.value > task.baseline.value,score=artifact.value,log=artifact.check_log)if task.kind == "upper_bound_proof":# Upper-bound proof: check proof validity first, then whether the bound is tighter than the baselinereturn Verdict(solved=verdict.proof_valid and artifact.upper_bound < task.baseline.upper_bound,score=task.baseline.upper_bound - artifact.upper_bound,log=verdict.review_log)if task.kind == "program_optimization":# Program optimization: check correctness first, then compare against the performance thresholdreturn Verdict(solved=artifact.correct and artifact.metrics.latency <= task.threshold.latency,score=artifact.metrics.speedup,log=artifact.test_log)raise ValueError("unsupported task kind")
The complete run flow can be summarized as:
def run_task(task, agent, trial_id):prompt = build_prompt(task, mode=task.mode)with sandbox(cpu=task.budget.cpu,mem=task.budget.mem,timeout=task.budget.max_wall_time_sec):artifact = agent.solve(prompt, budget=task.budget)verdict = judge(task, artifact)return {"task_id": task.task_id,"trial_id": trial_id,"task_version": task.version,"solved": verdict.solved,"score": verdict.score,"artifact_hash": sha256(artifact),"verifier_log": verdict.log}
There are three engineering points here:
- Traceable outputs: Deliverable hashes, verification logs, and task versions should all be recorded for easy review.
- Verifier decoupled from the solver: You cannot rely on model self-assessment; judgment should come from an independent script or expert process.
- Sandboxed execution: Code generated by the agent is untrusted input and must run in an isolated environment with resource and time limits.
3.3 Tiered Protocols: Full Mode and No-Lemma Mode
The third pillar is tiered protocols. They distinguish “completing the task with the help of external material” from “completing it with reasoning alone.”
- Full mode: The agent may call tools such as retrieval, code execution, subtask decomposition, and literature lookup, and may introduce intermediate lemmas on its own. This mode is closer to real research.
- No-lemma mode: Only the original problem is given, with no pre-provided lemmas, decomposition steps, or auxiliary scaffolding. If used to assess bare reasoning ability, web retrieval, external knowledge bases, and human hints should be explicitly disabled; if local code execution is allowed, that should also be declared in the task card.
This tiered design answers a key question: does a high score come from the model’s own reasoning and construction ability, or from external tools and human assistance?
4. Interpreting Results: Metrics, Tiers, and the Capability Landscape
4.1 Metric Definitions: Different Metrics Cannot Be Compared Directly
Evaluation results commonly include an overall score, theorem coverage, attempt success rate, and ranking. Different definitions must be stated separately, or reproduction and comparison will be affected.
Example results can be understood by the following definitions:
| Metric | Denominator and Sample | Counting Method | Example Result |
|---|---|---|---|
| Overall score ranking | 20 tasks | Full mode; tasks equally weighted and normalized; max 100 | 1st: 71.9, 2nd: 57.4 |
| No-lemma theorem coverage | 20 theorems | One attempt per theorem; solved theorems ÷ total theorems | 1st: 14/20, i.e., 70.0% |
| No-lemma attempt success rate | 60 attempts | Successful attempts ÷ total attempts | 2nd: 23/60, i.e., 38.3% |
| Other agents’ attempt success rate | 60 attempts | Same attempt-count basis | Highest: ~7/60, i.e., 11.7% |
The data can be traced by task-card version and leaderboard version, for example: the evaluation task-card version TCS-Agent-Eval-v0.9, the overall score from the full-mode leaderboard, the combinatorial construction task card eg5-v1.3, and the coding upper-bound task card code2210-v1.1. For reproduction, use the baseline values, submission formats, and verifier versions in the task cards as the reference.
This set of data shows three things:
- Clear capability tiers: There is a large gap between a few top agents and the rest of the participants.
- No-lemma mode is a watershed: Agents that rely on external scaffolding drop noticeably once the assistance is removed.
- Failures have a long tail: If an agent succeeds only on a few problems, its capability coverage is not stable.
4.2 Capability Is Not Across-the-Board Dominance
Research evaluation often does not show across-the-board dominance on a single dimension. For instance, in the alphabet-soundness task related to probabilistically checkable proofs (PCP), the second-ranked agent completed all three attempts, while the top-ranked agent failed to solve it.
This shows that current agents’ ability is more like a “capability jigsaw” than a whole that scales uniformly along a single dimension.
A task-level pass matrix can present these differences more clearly:
| Task Dimension | Agent A | Agent B |
|---|---|---|
| Combinatorial construction | Strong | Moderate |
| Bounds and proofs | Partial passes | Partial passes |
| Program optimization | Moderate | Moderate |
| PCP alphabet soundness | 0/3 | 3/3 |
Implications for engineering practice:
- Present results by dimension: An overall score only reflects the general level; a task-level matrix better reveals weaknesses.
- Match selection to the task profile: If the target scenario is highly similar to a certain task type, prioritize that type’s pass rate rather than only looking at the overall ranking.
4.3 Two Landmark Results: Independently Checkable New Objects
The most intuitive results in evaluation usually correspond to two kinds of research output: concrete objects and mathematical arguments.
The first is an extremal graph construction. In the “girth 5” task—requiring that the graph contain no triangles and no quadrilaterals—an agent constructed a graph with 124 vertices and 630 edges. The task card version is eg5-v1.3, with a baseline of 629 edges. The 630-edge construction satisfies both the triangle-free and quadrilateral-free constraints, so it constitutes a checkable improvement.
The second is a coding-theory upper bound. Another agent gave a proof of A(22,10) ≤ 82, tightening the upper bound of 84 recorded in the task card to 82. The task card version is code2210-v1.1. A(n, d) denotes the maximum number of codewords a binary code of length n and minimum Hamming distance d can hold—a classical parameter in coding theory. Improving such upper bounds usually requires new combinatorial or algebraic arguments and may draw on computer search to rule out counterexamples.
The engineering differences between the two are as follows:
| Comparison Dimension | Extremal graph construction | Coding-theory upper bound |
|---|---|---|
| Output form | A concrete graph object: 124 vertices, 630 edges | A mathematical argument: A(22,10) ≤ 82 |
| Verification method | A program checks the triangle and quadrilateral constraints | Expert review or formalized checking |
| Baseline source | Task card eg5-v1.3, baseline 629 edges |
Task card code2210-v1.1, baseline 84 |
| Implication for evaluation | Automatable verification; suitable for frequent regression | Hard to fully automate, but conclusions are independently checkable |
5. Building Your Own Verifiable Evaluation
5.1 Five Design Principles
- Draw tasks from real literature: Choose open problems that already have accepted baselines. The model may have seen related background, but a specific improvement cannot be obtained from memory alone, so this reduces contamination risk rather than eliminating it entirely.
- Write the verifier before releasing the task: Tasks without a reliable verifier should not enter the leaderboard.
- Report tiered results: Count full mode and no-assistance mode separately so that external scaffolding does not mask real capability.
- Sample multiple times rather than a single pass: Use metrics such as success rate, number of problems covered, and success rate per unit budget, rather than “a single pass counts as a pass.”
- Present by dimension: Keep a task-level pass matrix so users can see clearly “where it is strong, where it is weak.”
Anti-contamination measures can include:
- Closed problem statements: The statement should not contain baseline values, known constructions, proof ideas, or key lemmas.
- Time isolation: Evaluation problems and baselines should be released after the training-data cutoff, or a time split should be completed internally first.
- Version changes: Periodically change parameters, baselines, or task variants, and record the task-card version.
- Restricted retrieval: In bare-model mode, disable web retrieval and external knowledge bases.
- Human review: For proof-type tasks, introduce expert review or sampled audits.
5.2 A Minimal Cloud Evaluation Pipeline
From a systems-engineering perspective, a verifiable evaluation pipeline usually contains five modules: task management, sandbox execution, agent orchestration, verification and scoring, and result storage and visualization.
On general-purpose cloud products, this can be implemented as follows:
- Use a container platform to host an elastically scaling cluster for sandbox execution.
- Use object storage to hold task cards, artifacts, verification logs, and execution traces.
- Use a message queue to decouple task dispatch from score collection, supporting large-scale concurrent sampling.
- Use a logging service to record every step of the process.
- Use monitoring and alerting to detect abnormal task failure rates, resource overruns, or verifier errors.
A minimal security configuration should include:
- Container resource quotas: Limit CPU, memory, number of processes, and disk.
- Network egress restrictions: In no-lemma mode, disable external network access by default.
- Read-only baseline object storage: Baseline task cards and reference values cannot be modified by the task process.
- Log retention period: Retain at least until evaluation review is complete; a period of 90 days or longer per organizational policy is recommended.
- Artifact hash verification: Compute hashes for construction objects, proof texts, program packages, and verification results.
5.3 Common Pitfalls
- Reporting only the total score: This masks weaknesses across different task dimensions.
- Single sampling: Randomness significantly affects conclusions; report the results of multiple attempts.
- Prompt leakage: Baseline values, known constructions, or proof ideas should not appear in the context visible to the agent.
- Missing verifiers: Without an independent verifier, a task should not be placed on the official leaderboard.
- Inconsistent definitions: The overall score, attempt success rate, and theorem coverage must be stated separately.
6. Capability Boundaries: What AI Research Still Lacks
Verifiable evaluation can also clearly expose AI’s weaknesses. Under conditions of well-defined problems, ample budget, and verifiable feedback, current agents can complete some proofs, program optimizations, and construction improvements, but the following abilities are still clearly insufficient:
- Autonomous problem selection: Human researchers need to judge “which problems are worth doing.” Current agents still struggle to discover new problems or propose new conjectures on their own.
- Value judgment: Producing a result better than the baseline is one thing; judging whether that result is important or novel enough is another.
- Major open problems: Existing successes are mostly incremental improvements on known problems, not leapfrogging, original breakthroughs.
- Long-horizon self-correction: Real research requires adjusting direction amid many failures and judging whether a path is worth continuing.
To turn these boundaries into observable metrics, evaluation can add:
- Cross-turn correction rate: Whether the agent can revise its approach based on failure logs.
- Number of failure recoveries: The proportion of successes after experiencing failures within the budget.
- Convergence within budget: Whether a stable result is reached within the given number of turns, time, and calls.
- Human value scoring: Domain experts score the importance, novelty, and verifiability of the results.
- Autonomous problem-selection pass rate: Whether human experts consider a newly posed problem worth further research.
These metrics can turn “capability boundaries” from an abstract description into observable items that are recordable, traceable, and improvable in engineering.
7. Conclusion
The value of verifiable research evaluation lies not just in a leaderboard, but in providing a reusable method: defining tasks with real literature problems, ensuring objectivity with independent verifiers, distinguishing real capability from external support with tiered protocols, and depicting the capability landscape with multi-dimensional metrics.
For technical teams, the most important takeaway is: evaluating AI’s research ability is essentially designing a “research process that can be reviewed by machines.” Only when outputs can be independently verified can AI’s research ability be measured continuously and objectively, and only then can an engineering system iterate stably on this basis. And how to pose good questions, judge the value of results, and drive major breakthroughs—these remain topics left to human researchers.
