Evaluating LLM Research Capabilities: From Problem Solving to Verifiable Research

    High scores on competition problems do not automatically mean a large language model can do real research. This article examines why benchmark-style testing falls short for scientific tasks, and how to design verifiable evaluations that cover problem formalization, lemma decomposition, construction, program experiments, and proof checking. It covers design principles for research-oriented benchmarks, a validation pipeline with pseudocode, an anonymized results analysis showing why success rate and coverage must be read together, the current capability boundaries of AI research assistants, and practical engineering recommendations for turning evaluation into R&D infrastructure.

    Evaluating LLM Research Capabilities: From Problem Solving to Verifiable Research

    A large language model scoring high on competition problems does not automatically mean it can do scientific research. Competition problems typically have well-defined inputs, standard answers, and short reasoning chains. Research tasks, by contrast, involve multiple stages: problem formalization, lemma decomposition, counterexample construction, program experiments, proof checking, and judging whether a result matters. If evaluation only looks at final answers, it is hard to distinguish genuine, independently reviewable research output from a plausible-looking “new answer.” A more sound approach is to put the key artifacts of the research process into a single verifiable system: proofs that can be checked, constructions that can be validated, parameters that can be verified, and programs that can be reproduced.

    The Gap Between “Solving Problems” and “Doing Research”

    Research capability can be broken into at least four layers. The first is understanding and formalizing a problem. The second is proposing intermediate lemmas, constructing objects, or designing experiments. The third is getting outputs to pass an independent verifier. The fourth is judging whether a result is important and worth further investment. Under clearly defined problems, sufficient budgets, and verifiable feedback, current models can already complete partial proofs, program optimization, and construction improvements. But autonomously choosing research directions, judging the value of results, and tackling major open problems still require humans.

    This is also the key to evaluation design: do not just report a single final score. Task specification, attempt budget, intermediate feedback, validation methods, and failure records must all be included. Otherwise, a high success rate might simply come from repeated trial and error or insufficient verifier coverage, while a low success rate might only reflect a limited budget or missing feedback.

    Design Principles for Verifiable Evaluation

    An evaluation suite built for research tasks should follow these principles:

    • Well-defined problems: Task goals, input constraints, allowed tools, and output formats must be explicit. Avoid mixing “open exploration” with “standard proof” tasks.
    • Verification first: Every task needs an independent review mechanism. Proofs should be confirmed by a proof checker or human review; constructions should be checked against constraints such as vertex count, edge count, and forbidden subgraphs; program optimization should be checked for correctness and target value.
    • Controlled budgets: Record the number of attempts, time and compute budgets, and whether intermediate lemmas are provided. Success rates must be interpreted alongside budgets.
    • Multi-type coverage: Cover theorem proving, construction search, program optimization, and upper-bound improvement together to avoid bias from a single problem type.
    • Analyzable failures: Save the candidate object, validation log, and failure reason for every attempt, making it possible to distinguish “cannot solve,” “failed validation,” “insufficient budget,” and “wrong direction.”

    Evaluation Tasks and the Validation Pipeline

    A simplified evaluation pipeline can be abstracted as: task specification → multiple model attempts → independent validation → metric aggregation → reproducible archiving. Here is the pseudocode:

    1. def run_eval(task, models, budget):
    2. records = []
    3. for model in models:
    4. for attempt in range(budget.max_attempts):
    5. candidate = model.solve(
    6. task.spec,
    7. feedback=task.allowed_feedback,
    8. budget=budget
    9. )
    10. result = validate(task, candidate)
    11. records.append({
    12. "model": model.id,
    13. "task": task.id,
    14. "attempt": attempt,
    15. "candidate": candidate,
    16. "accepted": result.accepted,
    17. "reason": result.reason
    18. })
    19. if result.accepted:
    20. break
    21. return aggregate(records)

    The validate function should not rely on model self-assessment. Instead, use independent checkers, constraint validation scripts, or human review. For proof tasks, the output is not a “new answer” but an object, a set of parameters, or a proof that can be inspected. For construction tasks, the output should be directly verifiable against all constraints. For program optimization tasks, the output should include a runnable program, the objective value, and evidence of correctness.

    Anonymized Results: Not a Clean Sweep

    In an anonymized evaluation, two representative models scored 71.9 and 57.4 on the full leaderboard. Finer-grained settings showed more nuance: Model A completed 14 out of 20 theorems without intermediate lemmas provided, for a 70.0% success rate. Model B succeeded 23 times in 60 attempts, covering 9 distinct theorems, for a 38.3% success rate. The remaining six agents did not exceed 11.7%. These numbers show that attempt budget and theorem coverage must be read together: success rate reflects per-attempt efficiency, while coverage reflects cross-task generalization. Neither can substitute for the other.

    The results were not a clean sweep either. On an alphabet reliability task related to probabilistically checkable proofs, Model B completed it in all three attempts, while Model A failed to solve it. On an extremal graph construction task with girth 5, Model B produced a graph with 124 vertices and 630 edges containing no triangles or 4-cycles, beating the 629-edge reference value used by the task. In another upper-bound improvement task, Model A proved A(22,10) ≤ 82, tightening the previously published bound of 84 to 82. This shows that different models have strengths across different task families. Evaluation should focus on a “capability terrain map” rather than a single ranking.

    Capability Boundaries: What Works Now and What Still Needs Humans

    From an engineering perspective, models can already serve as “research assistants” within limited scopes: when the problem is clearly defined, verifiers are available, and the budget is sufficient, models can propose candidate lemmas, search for constructions, tune program parameters, and attempt to tighten upper bounds. If their outputs can be independently verified, they are valuable enough to enter the R&D pipeline.

    But the boundaries are equally clear. First, autonomous topic selection remains difficult: models struggle to judge which direction is worth investing in. Second, value judgment still depends on humans: a proof passing verification does not mean it is important. Third, major open problems require long-term strategy, domain intuition, and direction adjustment after failures—still fundamentally human-AI collaboration today. Fourth, insufficient verifier coverage creates “reward hacking” risk, where the model optimizes checkable metrics rather than the real objective. Fifth, data contamination and budget bias can distort evaluation conclusions, so reproduction packages and audit logs must be retained.

    Engineering Recommendations: Turning Evaluation into R&D Infrastructure

    If your team wants to use this kind of evaluation for model development or research assistance, consider these practices:

    1. Build a task specification library: Each task should include goals, constraints, allowed feedback, validation methods, and budget limits.
    2. Separate verifiers from generators: The generating model should not access verifier implementation details, reducing targeted optimization.
    3. Log attempt trajectories: Save every candidate output, validation result, and failure reason to support later attribution.
    4. Use multi-budget evaluation: Report single-attempt success rate, multi-attempt success rate, and task coverage together.
    5. Human-AI collaborative review: Separate “verifiable output” from “value judgment”—humans handle topic selection and conclusion assessment.
    6. Sandboxed execution: Run program optimization tasks in isolated environments with resource limits and logging.
    7. Reproducible archiving: Retain task versions, verifier versions, model configurations, and random seeds so conclusions can be re-verified.

    Returning to the original question: this work is best seen as a terrain map of AI research capabilities. Models can already complete partial proofs, program optimization, and construction improvements under clearly defined problems, sufficient budgets, and verifiable feedback. But autonomous research direction selection, result value judgment, and solving major open problems still require humans. For developers, the more realistic goal is not to claim “models can do research,” but to build verifiable evaluation, independent checking, and human-AI collaboration into R&D infrastructure—letting models continuously produce reviewable research artifacts within auditable boundaries.