Are Large Language Models Reliable for Research? A Verifiable Benchmark Gives the Answer

    For two years, "Can large language models do research?" has been debated repeatedly, yet most of the discussion stays at the level of impressions and offers little comparable or reproducible evidence. This article uses TCSExam—a benchmark for theoretical computer science built around independently verifiable outputs—as a sample map of AI research capability. It breaks down the benchmark's design: three types of checkable outputs, a separated verifier, explicit attempt budgets, and reference values anchored to the current best results. It then reads the results, explains where models still need human guidance, and shows how engineering teams can build their own verifiable benchmarks. The takeaway: once outputs can be independently checked, AI research capability stops being a matter of opinion and becomes a measurable, comparable, and improvable engineering metric.

    1. Introduction: From “Looks Right” to “Verifiable”

    Whether large models can do research has been debated repeatedly over the past two years. But most of these discussions stay at the level of impressions and lack comparable, reviewable evidence. The reason is not hard to understand: traditional benchmarks rely on multiple-choice answers or human/model scoring, and a high score often only shows that a model is “more similar” to a reference answer. Such signals struggle to reflect the true difficulty of research work. Whether a mathematical result holds, whether a piece of code is correct, and whether a construction genuinely beats existing results—these are the hard constraints of research.

    Recently, the founder of a large-model startup joined forces for the first time with a Turing Award winner who is also a professor at Tsinghua University to propose TCSExam, a benchmark for theoretical computer science. It brings an entire research workflow—“prove and derive, implement an algorithm, submit a result”—into a single automatically verifiable system. This article does not discuss the ranking of specific models. Instead, it treats the benchmark as one sample of an “AI research-capability map,” dissects the design thinking behind it, and explains how engineering teams can borrow that thinking to measure and improve the real capabilities of large models on professional tasks.

    1.1 Three Limitations of Traditional Benchmarks

    1. Answers can be approximate. Open-ended questions can be phrased in many ways, and scoring criteria easily waver between “close in meaning” and “substantively correct,” which is especially disadvantageous for disciplines that demand rigorous argument.
    2. Difficulty is hard to calibrate. A model may have seen highly similar problems in its training data, so it is difficult to tell whether a score reflects reasoning ability or memory.
    3. Process information is missing. Looking only at the final answer, you cannot tell whether the model found the key idea or “stumbled” onto the result through extensive trial and error. The latter is hard to reuse in real R&D.

    1.2 Why Theoretical Computer Science Makes a Good Touchstone

    Theoretical computer science studies algorithms and computational problems themselves, including proving lower and upper bounds, constructing combinatorial structures with specific properties, and improving existing algorithms. The conclusions of such work usually share three traits:

    • Precise statements, with no ambiguous areas;
    • Independently reviewable—anyone following the same steps reaches the same conclusion;
    • Cumulative results, where new work often takes the form of “improving on the best known result.”

    This means “right” and “wrong” can be defined in advance and judged automatically by a program. That is the prerequisite for turning subjective scoring into objective verification.

    2. Benchmark Design: Making Every Output Verifiable

    2.1 Three Core Types of Output

    The key principle of this benchmark is that the model delivers not a plausible-looking argument, but objects, parameters, or proofs that can be independently reviewed. By output form, tasks fall into three categories:

    Task type What the model must deliver Verification method
    Theorem proving A complete proof; in some tasks, also intermediate lemmas and how they combine Proof checking; missing a key step counts as incomplete
    Construction and optimization A concrete object (e.g., a graph) or concrete parameters A program directly checks all constraints and measures size or metrics
    Algorithm implementation Executable code Actually run and scored under the given dataset or runtime conditions

    What the three task types share is that the criteria are fixed before a task is released, and scoring relies on no subjective judgment.

    2.2 The Separated Verifier: The Core Design of Verifiable Benchmarks

    If the verification logic comes from the same code as the generation logic, or relies on the model’s self-assessment, the benchmark can end up “proving itself.” The reliable approach is a separated verifier that satisfies four design principles:

    • Independent implementation. The verifier uses a method completely different from the object under test; it never treats “the generator can produce it” as grounds for “the verifier will pass it.”
    • Only accepts objective evidence. It relies on data, configuration, proofs, or runtime results, and does not read the model’s self-descriptions or explanations.
    • Closed rules. All checks run inside a sandbox with limits on runtime and resources, rejecting any external network access and undeclared dependencies.
    • Hidden tests. Some test cases are not disclosed to the model, preventing it from “patching” against known cases.

    Illustrative code (pseudocode, language-agnostic):

    1. def evaluate(task, agent, budget):
    2. results = []
    3. for i in range(budget.max_attempts):
    4. artifact = agent.solve(task.statement, attempt=i) # Model output: a graph, code, or proof
    5. report = task.verifier.check(artifact) # Independent verifier, unrelated to the generation logic
    6. results.append({
    7. "attempt": i,
    8. "valid": report.valid,
    9. "metric": report.metric, # e.g., number of edges, runtime
    10. "cost": report.cost # Compute and time consumed by this attempt
    11. })
    12. if report.valid and task.scorer(passes=budget):
    13. break # Stop once the target is met, to control budget
    14. return {
    15. "pass": any(r["valid"] for r in results),
    16. "best": max((r["metric"] for r in results if r["valid"]), default=None),
    17. "success_rate": sum(r["valid"] for r in results) / len(results),
    18. "total_cost": sum(r["cost"] for r in results)
    19. }

    This pseudocode implies an important idea: the number of attempts is itself a budget variable. The same “success rate” means something completely different with one chance than with sixty, so it must be reported alongside the score.

    2.3 Explicit Budgets and Interpretable Scoring

    The published results include two noteworthy budget settings:

    • One theorem-proving task provides no intermediate lemmas, forcing the model to complete the entire derivation on its own;
    • Another class of tasks allows repeated searching within a larger number of attempts.

    The former tests the ability to succeed “in one shot”; the latter tests whether a solution can be found “after ample trial and error.” These measure different dimensions and cannot simply be added into a single total score.

    2.4 Using the Current Best Result as a Reference Value

    Construction tasks typically use the current best known result as a reference value rather than a fixed answer. For example, in a certain class of extremal graph construction tasks, the reference value is 629 edges. A graph submitted by the model counts as an improvement as long as it is valid and has more than 629 edges.

    This design shifts the benchmark from “answering correctly” to “pushing the boundary.” It brings two benefits: tasks do not saturate quickly as models improve, and results naturally carry comparable meaning. The cost is that reference values expire and need periodic updates as the field advances; otherwise, the meaning of “beating the reference value” weakens year by year.

    3. Reading the Results: A Map of AI Research Capability

    First, the overall data:

    Metric Top-ranked model Runner-up model The other six agents
    Full leaderboard score 71.9 57.4 None above 11.7
    Main task performance Completed 14/20 theorems without intermediate lemmas, 70.0% success rate 23 successes in 60 attempts, covering 9 different theorems, 38.3% success rate —
    Single-task performance (alphabet reliability task) Not solved Completed all 3 attempts —

    A few easily overlooked details deserve a closer look.

    3.1 Overall Lead Does Not Mean Comprehensive Lead

    The top-ranked model has a clearly higher total score, yet it failed to produce a solution on one alphabet reliability task, while the runner-up completed all three attempts. This shows that the total score is a composite of results across tasks; an advantage in one type of capability does not guarantee an edge on every task type. The lesson for users: do not choose a model by total score alone, but by its single-task performance on the task types you care about.

    3.2 Two Hard Results

    The two most striking results in the paper are neither arguments nor essays, but reviewable objects:

    1. Extremal graph construction. The model constructed a graph with 124 vertices and 630 edges that contains no triangles and no quadrilaterals, surpassing the reference value of 629 edges.
    2. Tightened upper bound in coding theory. The model proved A(22,10) ≤ 82, tightening the published upper bound of 84 to 82.

    In the first result, “girth 5” is exactly equivalent to “no triangles and no quadrilaterals” in a simple graph: the girth is the length of the shortest cycle, so a shortest cycle of 5 means there are no cycles of length 3 or 4. Since triangles and quadrilaterals have far fewer than 630 edges, these 630 edges can hardly be distributed uniformly in a simple graph. So the model’s breakthrough more likely came from discovering some special structure rather than from random search.

    In the second result, A(n,d) denotes the maximum number of codewords that can be held in a binary code of length n with minimum distance d. Tightening the upper bound from 84 to 82 shows that an arrangement of 84 codewords cannot satisfy all the distance constraints. The improvement is small, but it is a new result that can be independently reviewed.

    Together, these two examples illustrate that the model delivers not a “possibly correct” idea, but a concrete construction or proof that can be checked item by item. This is precisely where verifiable benchmarks deliver the most value.

    3.3 Success Rate and Coverage Must Be Read Separately

    The runner-up succeeded 23 times in 60 attempts but covered only 9 different theorems, meaning a fair number of attempts were concentrated on a few problems. The two capabilities each have value:

    • Single-attempt success rate measures the stability of “hitting on the first shot”;
    • Coverage measures “the range of problems that can be solved.”

    Research practice needs both. The former determines whether an automated pipeline can run stably; the latter determines how many kinds of problems a model can take on.

    4. Capability Boundaries: What to Delegate to Models, What Still Needs Humans

    The “map” above ultimately points to one judgment: given clearly defined problems, sufficient budget, and verifiable feedback, models can already complete some proofs, program optimizations, and construction improvements. But three lines remain clear.

    First, proposing problems is the human’s job. All tasks in the benchmark are given, and the model need not judge which problem is worth studying. Yet the hardest step in research is often distilling a truly important and solvable problem from a mass of phenomena.

    Second, judging the value of results is the human’s job. The benchmark defines progress as “beating the reference value.” Real research must also weigh: Does the improvement have general significance? Is it merely overfitting to a specific instance? Can it generalize to larger scales? These judgments require domain knowledge and are hard to automate.

    Third, major open problems still need to be led by humans. Such problems may lack a mature verification path and cannot be solved by trial and error within a limited budget. A model can be a capable search tool, but choosing directions, making trade-offs between approaches, and interpreting results still fall to researchers.

    A more realistic positioning, then, is to treat the model as a “research assistant” that searches efficiently under clear rules, while humans define the problem, design the verification method, and evaluate the results. Many cloud platforms that serve large-model APIs also bundle general-purpose capabilities beyond model serving, such as content moderation and observability; request and usage logs can then be used to account for evaluation costs. Which kind of service you adopt is not the point—what matters is keeping “generation” and “verification” always separated and retaining a complete, auditable record.

    5. Engineering Practice: How Enterprises Can Build Their Own Verifiable Benchmarks

    This thinking is not limited to mathematics. Many R&D scenarios naturally have objective verifiers; the key is to write those verifiers out explicitly. A general task specification can be defined like this:

    1. task:
    2. id: "example-optimization-001"
    3. category: "construction" # optional: proof / construction / program
    4. statement: "Minimize total cost under the given constraints and submit specific parameters"
    5. constraints:
    6. - "Parameter range: [0, 100]"
    7. - "Satisfy all business rules"
    8. reference_metric: 12500 # Reference value, e.g., the cost of the current solution
    9. optimization: "minimize" # Metric direction
    10. budget:
    11. max_attempts: 10
    12. timeout_per_attempt_seconds: 300
    13. verifier:
    14. type: "sandbox"
    15. hidden_tests_ratio: 0.5
    16. seed: 20240601 # Randomize test data to reduce overfitting risk
    17. scoring:
    18. pass_rule: "metric < reference_metric"
    19. report: ["success_rate", "best_metric", "total_cost"]

    In practice, you can follow five steps:

    1. Define a baseline for the status quo. Use the historical best solution, existing online metrics, or human results as the reference value, and measure all improvements against it.
    2. Convert subjective judgment into rules. What counts as “reasonable” in business can often be written as a set of hard constraints—budget caps, latency limits, compliance requirements—and handed to the verifier to check.
    3. Use randomization to prevent overfitting. Generate test data with a different random seed for each evaluation, and keep a portion of cases that are never disclosed.
    4. Unify cost reporting. Record the number of attempts, runtime, and compute consumption together. “Multiple attempts” without a cap destroys comparability and tends to waste resources.
    5. Rotate the task set regularly. Reference values expire, and public tasks get “gamed” on leaderboards, so new tasks need to be added continuously.

    On the infrastructure side, the evaluation pipeline is usually a three-stage flow of “task dispatch—sandbox execution—result verification”: tasks are distributed by a message queue; each attempt runs in a mutually isolated container; run artifacts are written to object storage for archiving, and execution logs go to a centralized logging service for search; and overall success rates and resource consumption are tracked continuously through monitoring and alerting. When compute investment is large, you can use the elastic scaling of a container platform to automatically scale up during evaluation peaks and release resources during troughs. For example, on Baidu AI Cloud, these general-purpose product categories can be combined into a complete evaluation pipeline. It is worth stressing that infrastructure only solves the problem of “running stably and accounting clearly”; whether a benchmark is trustworthy depends on the quality of the verifier itself.

    6. Common Pitfalls

    1. Leaving a backdoor in the verifier. Verification logic that is too lenient, or that lets the model submit its own “proof conclusions,” inflates scores. The verifier should be an independent component, maintained by a different team or process.
    2. Ignoring the attempt budget. A “success” achieved without limiting attempts may come from massive trial and error. Real systems must measure cost-effectiveness under a budget constraint.
    3. Looking only at the total score, not the distribution. A total score masks single-task differences; you should output a capability profile broken down by task type and difficulty.
    4. Lack of isolation causing cross-contamination. When multiple attempts share the same process or cache, a failed state from one attempt can “leak” into the next. The sandbox must guarantee that each attempt starts from a clean environment.
    5. Out-of-control costs. The stricter the automatic verification, the more expensive each evaluation becomes. You can use layered verification—“lightweight checks first, deep verification after passing”—to control costs.

    7. Conclusion

    The point of a benchmark is not the ranking itself, but that it lets us see three things clearly: what models can do, under what conditions they can do it, and how high the cost is. When outputs can be independently reviewed, AI’s research capability is no longer a matter of impressions but a measurable, comparable, and continuously improvable engineering metric.

    For teams evaluating whether large models can enter core R&D workflows, a pragmatic path is:

    • Start with tasks that have clear right-or-wrong answers and can be verified automatically, such as algorithm implementation, parameter tuning, and constraint-satisfaction problems;
    • Gradually expand to tasks that require construction and proof;
    • Always retain a human review step to judge the true value of results.

    This both leverages models to broaden the reach of “search” and holds the line on “judgment.”