AI Research Agent Evaluation: From Formal Proofs to Verifiable Discoveries
This article examines how AI research agents should be evaluated beyond question-answer benchmarks. It outlines a verifiable research workflow covering problem formalization, candidate generation, automated verification, result improvement, and research records. It discusses observed capability differences, representative outcomes such as discrete structure construction and tightened coding upper bounds, and why model outputs must become reviewable artifacts. It also covers key engineering challenges—verification cost, compute budgets, verifier reliability, and distinguishing reproduction from innovation—and concludes with realistic capability boundaries and future directions.
In recent years, AI models have made steady progress in code generation, mathematical reasoning, and scientific question answering. Yet a clear gap remains between “being able to answer a question” and “being able to participate in research.” Research does not merely require a model to produce a conclusion. It requires the model to pose questions, design methods, validate hypotheses, locate errors, and ultimately form an evidence chain that peers can review.
A recent study involving an AI research team and university mathematics researchers attempted to place these steps into a single verifiable system. The system does not judge model capability solely by whether the answer text is correct. Instead, it focuses on whether the model can generate formal proofs, executable programs, mathematical objects that satisfy constraints, and experimental results that can be independently checked. This approach provides a technical framework for evaluating AI research capability that is closer to the real research process.
1. Why Traditional Question-Answer Evaluation Is Not Enough
Traditional mathematics or programming benchmarks usually follow a “question—answer” structure. The model receives a problem, outputs a final result, and an evaluator matches it against a standard answer. This format is suitable for measuring basic knowledge and short-chain reasoning, but it struggles to cover the complexity of research work.
Research problems often have the following characteristics:
The answer may not be unique
In graph construction, coding design, or algorithm optimization tasks, there are often many answers that satisfy the conditions. Comparing only the final text cannot determine whether the model has truly completed the task.Hidden errors can appear in the process
A proof may fail at a lemma, and a program may pass only a small number of samples. Without automated checking, an invalid answer can easily be mistaken for a valid result.Research goals often involve improving existing results
Research tasks are not limited to verifying a known conclusion. They also include tightening upper bounds, enlarging constructions, and reducing algorithmic complexity. This requires the evaluation system to recognize new findings that are “better than the reference result.”Multiple rounds of trial and error and tool collaboration are needed
A real research process often includes literature retrieval, coding, running tests, revising hypotheses, and reproving. A single generative response cannot reflect this long-term iterative capability.
Therefore, a more reasonable evaluation target should be “verifiable artifacts,” not a single answer. Every key conclusion produced by the model should, as far as possible, be reviewed by a formal checker, a program execution environment, or an independent validation script.
2. Basic Workflow of a Verifiable Research System
A complete research agent system can generally be divided into five stages.
1. Problem Formalization
First, a natural language problem needs to be converted into clear mathematical or computational constraints. For example, a combinatorial construction problem can be represented as:
- Given a vertex set;
- Specify the number of edges or the structural scale;
- Forbid certain substructures;
- Require the complete object and its verification program as output.
The purpose of formalization is to reduce ambiguity and make subsequent automated checking possible. For proof tasks, it is necessary to specify the proposition, assumptions, definitions, and allowed foundational theories.
2. Solution Generation
The agent generates candidate proofs, algorithms, or structures based on the problem. It should not rely on a single inference pass. Instead, the model should be allowed to produce multiple candidate solutions and filter them based on historical feedback.
A more robust strategy is:
- First generate a rough idea;
- Split the idea into several verifiable subgoals;
- Generate a proof or code for each subgoal;
- Aggregate the results and run an overall check;
- Perform local repairs based on the failure location.
This decomposed workflow is better suited to complex tasks than directly asking the model to output a complete answer, because errors can be localized to specific steps.
3. Automated Verification
Automated verification is the core of the system. Different types of output require different checkers:
- Formal proofs are verified by a proof checker;
- Program results are run in an isolated execution environment;
- Graphs, codes, or other discrete objects are verified by constraint checkers;
- Numerical experiments are recomputed by independent scripts;
- Optimization results are compared with existing reference bounds.
It is particularly important that the verifier should not share exactly the same reasoning path as the generator; otherwise, correlated errors may occur. Ideally, the generative model proposes candidate solutions, and an independent verifier determines whether they hold.
4. Result Improvement
After a candidate result is verified, the system also needs to determine whether it improves on existing work. For example, an extremal problem may aim for “more edges,” while a coding problem may aim for a “lower upper bound.”
This requires the evaluation framework to store:
- Problem constraints;
- Reference results;
- Model output;
- Verification logs;
- Improvement margin;
- Reproducible experiment scripts.
Only when all this information is available can the framework distinguish between “correct reproduction” and “genuine improvement.”
5. Forming a Research Record
The final output should not be just a conclusion. It should include a complete research record, such as:
Problem definitionCandidate solutionsKey assumptionsGeneration processVerification commands or checking stepsVerification resultsComparison with reference valuesFailed attempts and reasons for revision
Such records support peer review and make it easier for subsequent models to continue the task. For enterprises and research institutions, they can also become searchable experimental assets.
3. Capability Differences Shown by Experimental Results
Observations from relevant evaluations show that different models perform very differently on research tasks. In a combined leaderboard, the best-performing model achieved a theorem completion rate of about 70%. Another model ranked second overall but had a success rate of about 40%. Most of the other evaluated agents were below 12%.
These data indicate that research agent capability is not simply a matter of “whether the model can reason.” It is determined by multiple factors:
- Whether it can accurately understand problem constraints;
- Whether it can choose an appropriate proof strategy;
- Whether it can use programs for search and verification;
- Whether it can adjust its approach based on failure feedback;
- Whether it can allocate attempts reasonably under a limited budget.
It is worth noting that the leading model did not have an advantage on every task. For example, in a task concerning the reliability of coding structures, another model completed the goal three times in a row, while the higher-ranked model failed to solve it. This shows that average scores cannot fully represent a model’s capability boundary. Research tasks are highly domain-specific. A model may be good at theorem proving but weak at discrete structure construction, or it may excel at program search while being relatively weak at abstract concept induction.
Therefore, research agent evaluation should not publish only a total score. It should also show task distribution, successful examples, failure types, and resource consumption.
4. Two Representative Types of Results
1. Discrete Structure Construction
In an extremal graph construction task, an agent generated a graph with 124 vertices and 630 edges that simultaneously satisfied the constraints of containing no triangles and no quadrilaterals. This result exceeded the reference value of 629 edges used in the task.
The difficulty of such a result is not in outputting a textual description of a graph. It must simultaneously satisfy multiple conditions:
- Vertex labels are complete and non-duplicated;
- The number of edges is exact;
- There are no self-loops;
- There are no duplicate edges;
- No three vertices form a triangle;
- No four vertices form a quadrilateral.
A reliable verification program can check these constraints through an adjacency matrix or adjacency list. Pseudocode is as follows:
Read the vertex set and edge setCheck whether vertex labels are validCheck for duplicate edges or self-loopsCount the number of edgesEnumerate triples of vertices and check for trianglesEnumerate quadruples of vertices and check for quadrilateralsOutput validation results for all constraints
This type of task reflects the model’s ability to “construct—run—revise.” The model does not necessarily need to design the final structure perfectly in one shot. It can also gradually approach a better solution through search, random initialization, local modification, and constraint checking.
2. Tightening an Upper Bound in a Coding Problem
Another result tightened a published upper bound for a coding parameter from 84 to 82. Such results usually require constructing a set of codewords that satisfies distance constraints and proving that its size does not exceed a certain value.
Unlike ordinary numerical problems, upper-bound proofs often involve combinatorial counting, linear algebra, probabilistic methods, or computer-aided search. If the model only states “the result is 82,” that does not show the problem has been solved. It must also provide a checkable derivation, or provide programs and certificates that can verify the key constraints.
This reflects an important principle in research evaluation: the size of the result is only the first-layer metric; the verifiability of the proof or certificate is the key determinant of credibility.
5. Why Model Output Must Be a “Reviewable Object”
In open-ended generation tasks, a model may produce fluent language with logical errors. Research scenarios impose higher reliability requirements, so outputs should be converted into the following types of objects wherever possible:
Formal proofs
Every step of reasoning can be checked by a proof system, avoiding reliance on ambiguous natural language.Executable programs
Programs can run in a controlled environment and output clear verification results.Structured data
Examples include graph edge sets, codeword lists for coding problems, and parameter configurations for optimization algorithms.Verification certificates
A certificate should be easier to check than the original search process, significantly reducing review cost.Reproducible experiment records
These include inputs, random seeds, runtime environment, version information, and result summaries.
This output format changes the design focus of research agents. The model is no longer merely “writing an explanation.” It must generate a set of research assets that other systems can take over and verify.
6. Key Engineering Challenges
1. Verification Cost Control
Formal verification and large-scale exhaustive search can be very time-consuming. The system needs a layered verification strategy:
- First perform fast syntax and format checks;
- Then perform local constraint checks;
- Finally execute high-cost full verification.
This avoids large numbers of invalid candidate solutions consuming computational resources.
2. Compute Budget Allocation
Research tasks often allow multiple attempts, but the number of attempts and runtime are limited. The agent needs to decide when to continue searching, when to abandon the current direction, and when to switch strategies.
The payoff of each attempt can be recorded, for example:
Candidate ID | Verification status | Target value | Improvement | Runtime
Based on these data, the system can prioritize more promising search paths instead of blindly repeating generation.
3. Preventing Verifier Failure
The verifier itself may also have vulnerabilities. Engineering measures should include:
- Using independent implementations for cross-validation;
- Writing counterexample tests for key conditions;
- Randomly generating known correct and incorrect samples;
- Recording verifier versions;
- Providing dedicated coverage for edge cases.
If the verifier incorrectly accepts an invalid result, the entire evaluation system loses credibility.
4. Distinguishing Reproduction from Innovation
When a model rediscovers a known result, it shows that the model has some reasoning and search capability, but this is not equivalent to producing innovation. Evaluation reports should clearly distinguish:
- Whether the original problem is satisfied;
- Whether the reference result is reproduced;
- Whether the reference result is exceeded;
- Whether a new proof route is provided;
- Whether verification or computation cost is reduced.
Only in this way can ordinary reproduction be prevented from being exaggerated into a major research breakthrough.
7. Correctly Judging the Capability Boundaries of Research Agents
At present, AI can already complete some theorem proving, program optimization, and combinatorial object construction under conditions of clear goals, sufficient compute budgets, and strong verification feedback. It is especially suited to tasks with clear objectives, explicit evaluation criteria, and automated verification.
However, there is still a clear gap between this and fully autonomous research, mainly in the following areas:
- Difficulty in judging which problems are truly important over the long term;
- Difficulty in accurately assessing the academic value of a result;
- Unstable understanding of implicit assumptions and research context;
- A tendency to fall into local search when facing open problems;
- Lack of stable research taste and direction-selection capability;
- Theoretical explanations of generated results may lag behind experimental findings.
Therefore, a more realistic positioning is a “research collaboration agent,” not a complete replacement for researchers. Humans are responsible for setting direction, judging value, and designing overall strategy. Models are responsible for expanding the search space, executing repetitive reasoning, generating candidate solutions, and completing automated verification.
8. Future Directions
Future research agent systems may evolve along three directions.
First, from single-task evaluation to long-term project evaluation. The system needs to observe whether a model can make sustained progress on a problem over days or weeks, rather than looking only at the result of a single submission.
Second, from result verification to process auditing. In addition to checking final conclusions, it is also necessary to analyze how the model chooses assumptions, how it uses failure feedback, and whether there are inexplicable shortcuts.
Third, from a single model to multi-agent collaboration. Different agents can take on roles such as problem decomposition, proof generation, program search, counterexample discovery, and result review, with an independent review module aggregating their outputs.
Overall, the greatest value of verifiable research systems is not to create the promotional effect that “models have replaced scientists.” It is to establish a more objective scale of capability. Such systems make it possible to quantify, reproduce, and compare AI’s mathematical reasoning, program search, and structural construction capabilities, while also helping researchers see the strengths and boundaries of models more clearly.
What truly deserves attention is not whether a model occasionally gives a surprising answer, but whether it can stably produce research outputs that are checkable, reproducible, and capable of being advanced further.
