Evaluating AI Research Capabilities: From Verifiable Artifacts to the Human-AI Boundary
AI-assisted research is shifting from generating plausible text to producing independently verifiable artifacts. This article presents an evaluation framework for developers and research teams to assess AI capabilities in scientific research. It explores the transition to verifiable artifacts such as formal proofs, constructive witnesses, and optimized programs. We also discuss the current capability landscape, highlighting what can be automated and what still requires human oversight, and provide actionable engineering guidelines for building a verifiable research pipeline.
Evaluating AI Research Capabilities: From Verifiable Artifacts to the Human-AI Boundary
AI-assisted research is shifting from “generating plausible text” to “submitting independently verifiable artifacts.” This shift is critical: when a model outputs not just a natural language answer, but a checkable proof, a verifiable construction, a set of reproducible parameters, or a regression-tested program, evaluation gains true engineering significance. Building on this theme, this article presents an evaluation framework for developers and research teams. We will also map the current landscape of AI research capabilities—identifying which stages can be automated and which still require human oversight.
1. Evaluation Targets: From Natural Language Answers to Verifiable Artifacts
Traditional QA benchmarks often compare the similarity between the final text and a reference answer. However, the core of a research task is not “similarity of expression” but “validity of the conclusion.” Therefore, an evaluation system must first define the types of verifiable artifacts. Common categories include at least the following:
Theorem Proofs: Models submit proof drafts, proof scripts, or derivable chains that can be reviewed by a checker. The verifier can check whether each step conforms to the rules and whether the final proposition is completely covered. The difficulty here is that natural language proofs are hard to verify; therefore, evaluations should ideally require structured proofs or formalizable intermediate steps.
Constructive Witnesses: For example, in combinatorics, constraint satisfaction, or graph theory tasks, the model submits a specific object. The verifier checks whether the object satisfies the required properties, exceeds reference values, and fits within size limits. The advantage of constructive tasks is objective verification: whether the object exists, the number of edges, or the presence of a specific substructure can all be determined programmatically.
Upper/Lower Bound Improvements: Models submit inequality proofs, enumeration certificates, or covering arguments. The verifier must not only check local derivations but also confirm the relationship between the conclusion and known upper/lower bounds. These tasks are highly sensitive to whether intermediate lemmas are autonomously proposed by the model, as providing lemmas significantly alters the task difficulty.
Program Optimization and Parameter Search: Models submit code, configurations, or scheduling schemes. The verifier checks correctness, performance regressions, and resource constraints simultaneously. These tasks are closer to engineering practices and make it easier to build automated feedback loops.
Putting research process outputs into the same verifiable system transforms “subjective trust” into “reproducible verification.” However, it is important to note that the verifier’s coverage determines the evaluation’s upper limit. A stronger verifier makes the evaluation closer to real research; a weaker one allows models to score high by “gaming the checker.”
2. Benchmark Protocol: Tasks, Budgets, Attempts, and Success Criteria
A robust verifiable evaluation protocol should include at least five dimensions: task specifications, budget, attempts, success criteria, and audit logs.
Task specifications must clearly define inputs, output types, allowed intermediate lemmas, resource limits, and success conditions. It is particularly important to distinguish between two settings: “with intermediate lemmas provided” and “without intermediate lemmas.” The former tests execution capability under given scaffolding, while the latter tests autonomous decomposition and planning. The two should not be conflated.
Budgets must specify the total number of attempts, per-attempt time limits, tool calls, and compute resources. Research tasks often cannot be completed in a single generation, so multiple attempts are reasonable. However, results must report the number of attempts, successful tasks, and coverage. Reporting only the “best successful attempt” will overestimate capability.
Success criteria should prioritize deterministic checkers: proof checking, property verification, numerical tolerance checks, and program regression tests. For tasks that cannot be fully formalized, manual review samples should be retained with clear review standards.
Audit logs must record the input, output, failure reason, artifact hash, environment version, and random seed for each attempt. Without audit logs, results are difficult to reproduce and failure modes are hard to analyze.
A simplified evaluation process can be abstracted as follows:
def evaluate(system, task, budget):attempts = []for i in range(budget.max_attempts):submission = system.solve(task.spec, budget.remaining())ok, reason = verify(task.spec, submission)attempts.append({"attempt": i,"submission": submission,"ok": ok,"reason": reason,"resource_used": budget.used()})if ok:breakreturn {"task_id": task.id,"success": any(a["ok"] for a in attempts),"attempts": len(attempts),"coverage": compute_coverage(attempts),"logs": attempts}
The verifier dispatches based on artifact type:
def verify(spec, submission):if spec.type == "proof":return proof_checker(spec.statement, submission.proof)if spec.type == "witness":return property_checker(spec.predicate, submission.witness)if spec.type == "bound":return bound_checker(spec.inequality, submission.certificate)if spec.type == "program":return correctness_and_perf(spec, submission.code)raise ValueError("unsupported task type")
The focus of this protocol is not the code itself, but the closed loop of “task spec – artifact – verifier – audit.” Only when this loop is established do the scores possess explanatory power.
3. Capability Landscape: Overall Lead Does Not Equal Comprehensive Lead
A common phenomenon in public benchmarks is that a system may lead in total score but experience reversals on specific sub-tasks. Another system might perform exceptionally well on certain constructive tasks but fail on reliability or constraint satisfaction tasks. This indicates that AI research capability is not a monotonic curve, but rather a topographical map.
From a task perspective, under conditions of “clear problems, verifiable feedback, and sufficient budgets,” models are already capable of completing partial proof drafts, construction improvements, and program optimizations. For instance, in classic extremal graph theory construction tasks, a system might submit objects exceeding reference values through search and verification; in upper bound estimation tasks, a system might tighten existing bounds using enumeration certificates or inequality derivations. The value of these achievements lies in the fact that the artifacts are verifiable, not just that the text looks professional.
However, the landscape also has obvious troughs. First, long-range planning remains fragile: selecting the wrong intermediate lemma in a multi-step proof leads to cascading failures. Second, failure recovery is inadequate: models often struggle to adjust strategies effectively after receiving verifier feedback, instead repeating similar attempts. Third, there is a risk of overfitting to the verifier: if evaluation feedback is too singular, the model might learn to “please the checker” rather than truly solve the problem. Fourth, open problem selection and value judgment still rely on humans: choosing which direction is worth pursuing, which result is meaningful, or which proof is more elegant is currently very difficult for a model to accomplish independently.
Therefore, an evaluation report should not just provide a total score, but a multi-dimensional profile: proof success rate, construction success rate, average number of attempts, budget efficiency, failure reason distribution, and sub-task reversals. The fact that most systems still have low success rates on complex tasks precisely illustrates that capabilities are sparse, not comprehensively dominant.
4. Engineering Implementation: Building a Verifiable Research Pipeline
For developers and enterprises, the greater value lies not in watching leaderboards, but in applying the concept of verifiable evaluation to their own R&D pipelines. You can build this pipeline across the following layers:
Spec Layer: Use structured descriptions to define task types, inputs/outputs, verifier versions, and success conditions. Specs should be versioned to prevent results from being incomparable due to “different standards for the same task.”
Execution Layer: Run model-submitted code or proof scripts in isolated sandboxes, setting resource quotas, network isolation, and deterministic environments. Artifacts, logs, and environment images should be uniformly saved. Here, general-purpose capabilities like Baidu AI Cloud’s object storage, container platform, logging services, and monitoring can be leveraged to build a reproducible execution and audit environment.
Verification Layer: Implement proof checkers, property checkers, numerical tolerance checkers, and program regression tests separately to avoid overloading a single verifier. Add independent reviews and adversarial sample testing for high-risk conclusions.
Audit Layer: Record artifact hashes, random seeds, dependency versions, failure samples, and manual review conclusions. The audit layer is the foundation for subsequent analysis and model iteration.
Human-AI Collaboration Layer: Humans are responsible for topic selection, defining verification standards, judging result value, and reviewing anomalies; models handle candidate generation, search, proof drafts, code optimization, and failure retries. Shift human duties forward to “problem definition and verifier design,” rather than modifying model outputs line by line after the fact.
A task description can be abstracted as follows:
{"task_id": "constructive-witness-001","type": "witness","spec": {"predicate": "no_forbidden_substructure","size_limit": 200,"objective": "maximize_edges"},"budget": {"max_attempts": 20,"wall_time_s": 600},"verifier": {"name": "property-checker","version": "1.0"},"artifacts": ["witness.json", "run.log"]}
Such structured tasks are easier to compare than free text and more easily沉淀 into internal team benchmarks.
5. Selection and Adoption Advice
When evaluating AI research capabilities, developers and enterprises are advised to follow these principles:
- Do not just look at total scores. Check whether the verification loop is complete, whether failures are explainable, whether attempts are transparent, and whether sub-tasks cover key capabilities.
- Build an internal task set. Start from verifiable problems in your business, and retain hidden test sets to prevent the model from overfitting to public feedback.
- Report both success rate and coverage. The difference between “succeeding once” and “stable success” under multiple attempts is significant. The coverage of theorem counts, task counts, and failure distributions is equally important.
- Tiered budgets. Conduct candidate search first, then proof checking, and finally manual review. Cache verification results to avoid redundant computation.
- Mandatory manual review for high-risk conclusions. Especially for bound improvements, formal proofs, and construction results that affect business decisions, keep independent review records.
6. Conclusion
AI research capability evaluation is shifting from “how similar the answer is” to “whether the artifact can be independently reviewed.” Verifiable systems put proofs, constructions, parameters, and programs into the same checking framework, making model capabilities comparable, reproducible, and auditable. Public benchmarks present more of a topographical map: under clear problems, sufficient budgets, and verifiable feedback, models can already complete partial proofs, program optimizations, and construction improvements. However, autonomously selecting research directions, judging the value of results, and solving major open problems still离不开 humans.
For developers, the truly reusable asset is not a leaderboard score, but the engineering closed loop of “task spec – sandbox execution – verifier – audit log – human-AI review.” Building this closed loop is what transitions AI research capabilities from demo to usable.
