Verifiable Evaluation: The Real Boundaries of LLM Research Capabilities
As large language models move into coding, mathematics, and automated research, judging whether they can "do research" can no longer rest on how fluent their output looks. This article argues that the reliable standard is verifiable results—proofs that pass a proof checker, programs that compile and pass their tests, and constructions that satisfy every constraint. Drawing on verifiable evaluation, automated verification, and research automation, it covers which tasks suit this approach, the three pillars of a trustworthy evaluation system, how to read leaderboard results through multiple metrics rather than a single score, a technical look at two verifiable outcomes, a capability map of what can be automated versus what still needs humans, and a low-cost path to implementation.
As large language models enter coding, mathematics, and automated research scenarios, judging “whether a model can do research” can no longer stop at text fluency. The truly reliable standard is whether the model can deliver independently verifiable results: a proof that passes a proof checker, a program that compiles and passes its tests, or a mathematical construction that satisfies every constraint. Building on verifiable evaluation, automated verification, and research automation, this article discusses the real boundaries of LLM research capabilities and offers engineering methods that can be put into practice.
1. Which Research Tasks Suit Verifiable Evaluation
Verifiable evaluation is not a universal solution; it fits three kinds of tasks especially well:
- Clear problem goals: the input, the objective, and the success criteria are well defined.
- Objective ground truth: a proof either holds or it does not, a program either passes all tests or it fails, and a construction either satisfies the constraints or it does not.
- Controllable verification cost: automated checking can be completed within a clear budget.
For these reasons, research tasks commonly suited to verifiable evaluation include theorem proving, program optimization, constant improvement, combinatorial construction, code repair, and benchmark testing. What matters here is not “whether the wording looks elegant” but “whether the result can be checked independently by a machine.” By contrast, tasks that depend on experimental data, domain taste, social-value judgment, or long-horizon hypothesis reasoning can still use LLMs as assistants, but should not rely on automated evaluation alone to reach conclusions.
This can be summarized as:
- Suitable: theorem proving, program optimization, mathematical construction, code testing, and rule-based constraint verification.
- Use with caution: research topics where domain experts must judge importance.
- Not suitable for direct automatic scoring: topic value, scientific significance, data compliance, and social-impact assessment.
Put differently, verifiable evaluation does not replace research judgment; it separates the parts that can be objectively verified from the parts that remain subjective discussion.
2. The Three Pillars of a Verifiable Evaluation System
A credible research evaluation framework needs at least three pillars: an independent verifier, budget constraints, and clearly defined problem boundaries and success criteria.
An independent verifier decides whether a candidate result is valid. Proofs require a formal checker to verify the logic line by line, code requires a compiler and a test suite to run, and mathematical constructions require property checkers that traverse the constraints. The verifier must be decoupled from the generating model to avoid circular reasoning in which a model both produces and grades its own output.
Budget constraints separate stable capability from lucky hits. If unlimited attempts were allowed, a model might “brute-force” a high score through massive trial and error, which says little about real research ability. A budget can cap the number of attempts, generated tokens, runtime, or call cost.
Clearly defined problem boundaries and success criteria keep evaluation reproducible. Every task should specify its input, objective, and pass conditions, so that “was it completed?” becomes a boolean that can be decided automatically rather than a vague comparison of quality.
The following sketch shows the core loop of this kind of evaluation, and adds notes on failure classification, duplicate-candidate blocking, resource caps, and cache deduplication:
import timefrom dataclasses import dataclassfrom hashlib import sha256@dataclassclass Budget:max_attempts: int = 20max_tokens: int = 80000max_seconds: float = 600.0@dataclassclass VerifyResult:status: str # PASS / FAIL_SYNTAX / FAIL_PROOF / FAIL_CONSTRAINT / TIMEOUTcost: int = 0 # budget consumed by this verificationmessage: str = ""def candidate_key(candidate: str) -> str:return sha256(candidate.encode("utf-8")).hexdigest()def verifiable_eval(model, task, verifier, budget: Budget):seen = {} # cache deduplication and duplicate-candidate blockingfailures = {}attempts = 0total_cost = 0start = time.monotonic()while (attempts < budget.max_attemptsand total_cost < budget.max_tokensand time.monotonic() - start < budget.max_seconds):attempts += 1candidate = model.generate(task)key = candidate_key(candidate)if key in seen:failures["duplicate"] = failures.get("duplicate", 0) + 1continueresult: VerifyResult = verifier.check(candidate, task)total_cost += result.costseen[key] = result.statusif result.status == "PASS":return {"solved": True,"candidate": candidate,"attempts": attempts,"cost": total_cost,"failure_stats": failures,}failures[result.status] = failures.get(result.status, 0) + 1return {"solved": False,"candidate": None,"attempts": attempts,"cost": total_cost,"failure_stats": failures,}
The key point is that verifier.check is independent of the generating model: whichever model produces a candidate, the verification standard is identical. Only then does cross-model comparison mean anything. Failure classification matters just as much. Syntax failures, proof gaps, constraint violations, timeouts, and duplicate candidates each point to a different capability gap. In practice, teams should avoid labeling every failure as “the model is bad” and instead use the distribution of failures to locate where the real problem lies.
3. Reading Leaderboard Results Correctly: Look at Structure, Not Simple Dominance
On a comprehensive leaderboard, the gap between the leading model and the runner-up can be substantial. For example, under a fixed budget, with the same verifier and no intermediate lemmas provided, the leading model might complete most of the target theorems, while the runner-up covers fewer distinct tasks and the remaining participants fall into lower bands. But if such results are read simply as “complete dominance,” the structural differences in research capability are easy to miss.
Capability tends to be complementary across tasks. On a specific problem, the runner-up may pass on the first try again and again, while the top model fails to solve it at all. This shows that:
- Average scores can mask task heterogeneity. Research tasks span algebra, combinatorics, complexity, coding, and formal proofs, so model capability looks more like a terrain map than a single number.
- Coverage and success rate need to be read separately. Hitting more distinct tasks under many attempts reflects breadth, while the first-try pass rate reflects stability.
- Verification brings credibility, not a reset of difficulty. Reproducibility guarantees that “solved means solved,” but it does not automatically make the underlying problem easier.
When reading leaderboards, use several indicators together:
| Metric | Meaning | Use |
|---|---|---|
| Success rate | Proportion of tasks passed at least once | Measures ultimate solving ability |
| Coverage | Proportion of distinct tasks solved | Measures task breadth |
| First-try pass rate | Proportion passed on the first attempt | Measures stability |
| Budget consumption | Average attempts, tokens, and time | Measures cost and efficiency |
| Failure distribution | Types of failure such as syntax, constraint, or proof | Locates model bottlenecks |
Only by reading these indicators together can you avoid the misreading that “the top model must lead across the board.”
4. A Technical Look at Two Verifiable Results
The most persuasive outcome in an evaluation is not a model producing a plausible-sounding new idea, but a model delivering a concrete output that can be independently verified. Two typical scenarios illustrate this.
The first is extremal graph construction. Here the model must produce a graph structure that satisfies the required vertex count, edge count, and forbidden-subgraph constraints. If the model’s construction surpasses the task’s preset reference value and any third party can check the constraints line by line with a program, the result carries high credibility. Its value lies not in how complete the text description is, but in the fact that it genuinely passed the rule checks.
The second is upper-bound tightening. If a model proves that some combinatorial quantity satisfies a tighter upper bound, and that proof passes a formal check or rule-based verification, it becomes a deterministic increment of knowledge. Unlike a “might be better” guess, such a result can be recorded, cited, and built upon.
Together these cases reveal a methodological point: only increments that a machine can review are trustworthy increments. The purpose of verifiable evaluation is precisely to turn “looks good” into “can be checked.”
5. A Capability Map: What Can Be Automated and What Still Needs People
A verifiable evaluation framework looks more like a map of AI research capabilities than a simple leaderboard. It traces where the current boundaries lie.
Areas where models already perform well include:
- Completing some theorem-proving tasks when the problem is clear, the budget is sufficient, and the feedback is verifiable.
- Carrying out deterministic program optimization and constant improvement.
- Producing mathematical constructions that satisfy hard constraints and pass the verifier.
- Iterating on candidate solutions based on feedback when failure classification is clear.
Areas that still depend on people include:
- Autonomous topic selection: deciding which problem is worth researching requires domain taste and strategic judgment.
- Value assessment: judging whether a result “matters” usually goes beyond what a verifier covers.
- Attacking major open problems: these often demand long chains of reasoning and lack immediate verifiable feedback.
- Data compliance and ethics review: questions of privacy, security, and research norms require human oversight.
In engineering practice, a human review checklist can be added:
- Topic-value review: does the problem have research significance and business value?
- Data-compliance review: are the training, validation, and test data lawful and compliant?
- Proof review: are the key proofs, constraint boundaries, and verifier versions traceable?
- Reproducibility records: are the task, model, budget, and verifier version fully preserved?
- Risk review: are there misleading conclusions or high-risk, hard-to-explain outputs?
In short, a verifiable framework lets models excel in segments that have a standard answer and can be scored automatically, but in segments that require defining the problem and assessing its significance, humans remain in the lead.
6. Engineering Takeaways: Start with Low Cost
For teams that want to build a similar verifiable research evaluation capability, a low-cost starting point works well: build a single-task verifier first, add logging and result archiving, and you have basic reproducibility. From there, gradually expand the task set, model integrations, and budget governance.
The following actionable checklist is worth focusing on:
- Verifier interface: takes a candidate, a task description, and budget parameters as input, and returns the verification status, failure category, resource consumption, and error message.
- Task versioning: version the task set, reference solutions, verifier version, random seeds, and dependency environment.
- Budget records: record the number of attempts, generated tokens, verification time, call cost, and reasons for failure.
- Failure retries: distinguish syntax errors, constraint failures, proof gaps, timeouts, and insufficient resources to avoid ineffective retries.
- Success-rate and coverage metrics: track first-try pass rate, cumulative pass rate, average budget, and coverage across different tasks at the same time.
- Observability: log every generation and verification step through a logging service, and track swings in budget consumption and success rate through monitoring and alerts.
At the infrastructure level, general cloud capabilities can support such a system. For example, object storage can version task sets, reference solutions, and verifier versions; a container platform can run stateless verification services and scale them elastically; message queues can smooth out traffic spikes and keep large-scale concurrent verification from overwhelming the system; and logging and monitoring can track the cost and outcome of each attempt.
In this way, a team can turn “verifiability” from an idea into engineering, rather than leaving it at the conceptual stage.
Conclusion
The value of verifiable evaluation lies not in crowning any particular model, but in pulling the discussion of LLM research capability back from subjective impressions to objective facts. When a model’s output can be independently reviewed, we can both measure its capability boundaries more accurately and see the boundaries of the human-machine division of labor more clearly. For developers and researchers, the direction truly worth investing in is building more tasks and tools whose results can be reviewed. Because on the long road of research, every verifiable step is a step you can stand on.
