Verifiable Evaluation: How to Scientifically Measure the Research Capabilities of Large Language Models
Benchmarks saturate quickly, yet their scores increasingly fail to match real capability. This article explains verifiable evaluation, in which a model must produce artifacts that a deterministic verifier can independently re-check, such as proofs, programs, or constructed objects. It covers the three main research-level task types, the multi-dimensional metrics used instead of a single score, and a reference evaluation pipeline built on sandboxed execution, deterministic verification, budget control, parallel sampling, and artifact retention. It closes with a capability landscape of current AI research abilities and four practical recommendations for building verifiable evaluation platforms.
1. Why traditional benchmarks look informative but fail to explain
Over the past two years, benchmarks have saturated rapidly, and model scores on standardized problem sets keep climbing. Yet researchers generally feel that benchmark results no longer line up with real capability. Three factors stand out:
- Contamination from memorized data: training corpora may already contain the benchmark questions themselves, so a high score does not necessarily indicate generalization.
- Answers that cannot be judged true or false: open-ended questions often have no single correct answer, and human grading is both subjective and costly.
- The illusion of fluency: models are good at producing text that reads as if it were correct, whereas the bar in research is precisely whether the work can be rigorously verified.
To measure research capability, the evaluation target has to shift from the answer to the evidence.
2. What verifiable evaluation means
The core definition is simple: the model’s output must be an object that a deterministic verifier can independently re-check, not a new claim that merely looks plausible.
Typical acceptable outputs include:
- a proof that a formal checker can verify line by line;
- a program that runs in a sandbox and passes test cases;
- a constructed object whose properties can be checked by machine (graphs, encodings, schedules);
- a set of parameters or configurations whose objective values can be computed exactly.
In other words, the model delivers not an opinion but re-checkable evidence. Scoring then shifts from repeating what others say to a binary or graded judgment: does the result pass verification or not.
3. Three forms of research-level evaluation tasks
3.1 Proof-based tasks
The model must produce a complete proof of a mathematical statement, and the verifier checks whether each step of reasoning holds. Such evaluations typically use difficulty tiers: one tier lets the model introduce intermediate lemmas of its own, while another demands a “zero-hint, straight-through” proof, where difficulty rises sharply.
3.2 Program optimization tasks
The model outputs a program or algorithm, and evaluation measures its correctness and performance (for example, runtime and resource usage) on a benchmark suite, replacing subjective impression with objective metrics.
3.3 Constructive improvement tasks
This is the category that best reflects research value. Take extremal graph theory: the model must construct an object that satisfies specific constraints — for example, “as many vertices and edges as possible, while the graph contains neither triangles nor quadrilaterals” — and the verifier checks whether every constraint actually holds. Similarly, in coding theory, the model may attempt to tighten a published bound and provide a verifiable derivation. The output here is a concrete construction or a tighter bound, and its quality can be measured precisely.
4. Scoring and metrics: don’t hide structure behind a single score
A good research evaluation must be a capability profile, not a lone total score. Common dimensions include:
- Success rate under a fixed budget: for example, allow 60 attempts, then count the successes and compute the success rate, reflecting stability.
- Coverage breadth: how many different problems were solved, rather than repeated attempts on the same one.
- Performance by difficulty tier: pass rates under the “with intermediate lemmas” and “without intermediate lemmas” modes.
- Verifiability of results: whether the result passed formal verification or only heuristic tests.
Results typically show a pronounced long-tail distribution: leading models complete a relatively high share of tasks, while most models have notably low pass rates. More importantly, top-ranked models still fail on certain specific tasks, and those are exactly the tasks another model solves reliably. This is a reminder that capability is not a single, level surface; it has structure and blind spots.
5. Verifiers and execution architecture
Turning this design into practice requires a reliable execution and verification pipeline:
- Sandboxed execution: provide isolated runtime environments for program and construction tasks to prevent side effects and security risks.
- Deterministic verification: prefer rule-based formal checkers or property-based tests over letting another model “grade”. Verifiable tasks should be rule-based wherever possible.
- Budget control: set explicit limits on tokens, compute, and execution time to keep evaluations fair and costs under control.
- Parallel sampling: to compute success rates and coverage, run multiple attempts concurrently.
- Artifact and trace retention for reproducibility: record every output and verification step so conclusions can be reproduced.
Below is a schematic evaluation framework:
def evaluate(task, model, attempts=60):successes = []for _ in range(attempts):raw = model.generate(task.prompt) # model outputartifact = parse_artifact(raw) # parse into proof/program/constructionif artifact is None:continueif verifier.check(task, artifact): # deterministic verificationsuccesses.append(artifact)solved_ids = {a.task_id for a in successes}return {"success_rate": len(successes) / attempts, # success rate under the fixed budget"coverage": len(solved_ids), # number of distinct problems solved"artifacts": successes, # re-checkable artifacts}
In engineering terms, this pipeline usually runs on elastic infrastructure: a container platform hosts the isolated sandboxes, object storage keeps artifacts and logs, and logging, monitoring, and alerting services keep the system observable. Baidu AI Cloud’s container, object storage, logging, and monitoring capabilities can serve as the infrastructure foundation for such an evaluation platform, letting teams focus their effort on the verification logic itself.
6. What the results reveal: a terrain map of AI research capability
Overall, verifiable evaluation is closer to a terrain map that reveals the boundaries of capability than a simple report card:
- Capabilities already present: when the problem definition is clear, the budget is sufficient, and feedback is verifiable, models can complete a substantial share of proof, program optimization, and constructive improvement tasks. They can even produce independently re-checkable results that exceed known reference values or tighten existing upper bounds.
- What still depends on humans: choosing problems autonomously, judging the value and novelty of results, and cracking genuinely important open problems.
7. Practical advice for builders
- Make the task library verifiable, reproducible, and tiered by difficulty — first ensure that answers can be judged true or false by machine.
- Prioritize verifiers over scoring models: anything that can be formalized should not rely on subjective judgment.
- Use a multi-dimensional profile instead of a single total score, exposing blind spots rather than masking differences.
- State budget constraints explicitly, so that evaluation conclusions are comparable under equal resources.
Conclusion
The value of verifiable evaluation is that it moves AI research capability from “stunning demos” to “checkable progress”. For teams that want to build AI research tools, the most important principle is to build verifiability into the tasks, outputs, and scoring from the very start of the design. Only then can we truly answer the original question — how far has AI actually come on the path of research?
