Skip to content
Stories. Ideas. Perspectives.
TEST OUR GAMEPlay Slidy Ball

The AI Benchmark Trap: Why High Scores Do Not Always Mean Better AI Models

Artificial intelligence companies regularly announce new records. One model achieves a higher score on a reasoning examination, another solves more programming problems, and a third claims to outperform experienced professionals on workplace tasks. These announcements often arrive with impressive percentages, colorful leaderboard graphics and comparisons against previous generations of AI systems. Yet an increasingly important question sits behind the excitement: how do researchers know that a higher AI benchmark score actually represents a better model?

The answer is more complicated than checking which system achieved the largest number. An AI benchmark is a measurement instrument, not a complete description of intelligence. Its results depend on the questions selected, the quality of the expected answers, the evaluation method, the information available to the model and the conditions under which the experiment takes place.

In November 2026, this issue has become particularly important as AI systems move beyond answering isolated questions. They are being evaluated on programming projects, research assignments, document production, scientific reasoning and extended computer-based tasks. A model that performs exceptionally well on a fixed examination might still struggle with an unfamiliar problem, misunderstand an instruction or produce an impressive-looking answer containing serious factual mistakes.

Researchers are consequently reconsidering what it means to measure AI progress. Instead of relying on one examination or a single leaderboard, stronger evaluation methods combine multiple tasks, independent testing, statistical analysis, human judgment and practical demonstrations.

One particularly revealing example comes from software engineering. SWE-bench Verified became an influential way to compare AI coding systems. However, on February 23, 2026, OpenAI explained why it had stopped using the benchmark to measure frontier coding capabilities, citing contamination and problems with evaluation tests. Its proposed successor, SWE-bench Pro, subsequently faced its own independent and internal audits. A refreshed public version, SWE-bench Pro V2, was released in September 2026.

These developments do not demonstrate that AI progress is imaginary. They reveal something more important: measuring progress accurately is becoming a scientific challenge of its own. Understanding that challenge helps consumers, businesses, developers and policymakers distinguish genuine improvements from impressive numbers that require closer examination.

1. What AI Benchmarks Actually Measure

An AI benchmark is a standardized collection of tasks designed to measure one or more characteristics of an artificial intelligence system. It provides researchers with a consistent way to compare different models under defined conditions.

The basic idea is familiar. Students take examinations to demonstrate knowledge, athletes complete timed events to demonstrate physical performance, and computers undergo standardized tests to evaluate processing capabilities. AI benchmarks apply a similar principle to machine learning systems.

However, artificial intelligence systems are unusually versatile. A language model can answer scientific questions, summarize legal documents, write computer programs, translate languages and generate creative content. Measuring all these abilities with one examination is therefore unrealistic.

Different benchmarks measure different abilities

Researchers create specialized benchmarks because different tasks require different forms of performance.

  • Knowledge benchmarks: Evaluate whether models can answer questions about science, history, mathematics and other subjects.
  • Reasoning benchmarks: Test the ability to solve unfamiliar problems, follow logical steps and combine information.
  • Coding benchmarks: Measure whether AI systems can understand software requirements, modify code and pass relevant tests.
  • Instruction-following benchmarks: Examine whether models respect formatting requirements, constraints and detailed user instructions.
  • Safety benchmarks: Investigate whether systems produce harmful outputs, follow malicious instructions or fail under adversarial conditions.
  • Multimodal benchmarks: Assess the ability to interpret combinations of text, images, audio and video.
  • Efficiency benchmarks: Measure computing resources, response time, energy consumption and financial costs associated with completing tasks.

These categories reveal an important distinction: a benchmark measures performance on a defined collection of tasks, not every possible capability of the system.

The difference between a model and an AI application

Another important distinction concerns what researchers are actually testing.

A language model is the underlying computational system that generates responses. An AI application, however, may include additional components such as internet search, external databases, programming tools, memory, document retrieval and automated workflows.

Imagine two companies testing their products on the same research assignment. The first gives its model only the original question. The second provides its model with web access, a document-search system, a calculator and several opportunities to revise its response.

If the second product performs better, that result does not necessarily prove that its underlying model is more capable. The additional tools may explain part or even most of the improvement.

Both experiments can be useful, but they answer different questions. One measures model performance under controlled conditions; the other measures the performance of a complete AI system.

This distinction becomes especially important with AI agents. An agent may use a language model to plan actions, a browser to retrieve information, a programming environment to execute code and a verification system to inspect its results.

A high score achieved by such an agent reflects the combined performance of its model, tools, instructions, software environment and execution strategy.

Why researchers need several measurement dimensions

Stanford University's Center for Research on Foundation Models developed the Holistic Evaluation of Language Models framework, known as HELM, to encourage broader and more transparent evaluations.

The original HELM research evaluated language models across 16 core scenarios and seven metrics. Its approach considered accuracy alongside characteristics such as robustness, fairness and efficiency.

The researchers also emphasized standardized conditions and public access to evaluation prompts and model responses. Their central argument was that language models should be assessed across a broad range of scenarios rather than through isolated scores.

The HELM framework remains an important reference for understanding holistic evaluation, although its GitHub project entered maintenance mode on June 1, 2026. This is another reason to distinguish an established evaluation framework from a continuously updated leaderboard.

For anyone following the AI industry, the central lesson is simple: before accepting a benchmark result, identify precisely what was measured, what was excluded and which parts of the complete AI system contributed to the result.

2. Why One Score Cannot Measure Intelligence

One of the most common problems in AI reporting is the tendency to compress complicated performance into a single percentage.

A company might announce that its newest model achieved 85 percent on a benchmark, while its competitor achieved 81 percent. The natural interpretation is that the first model is better.

But better at what?

If the examination measures mathematical reasoning, the result says something about mathematical reasoning under those particular testing conditions. It does not automatically establish that the same model is better at writing, scientific research, understanding images or making reliable decisions.

Accuracy is only one dimension

Accuracy is often the easiest metric to understand. It represents the proportion of questions answered correctly or tasks completed successfully.

However, accuracy can conceal important differences.

Consider two hypothetical AI systems answering questions about medical information. Both achieve 95 percent accuracy on a particular evaluation set.

The first system gives a correct answer in almost every situation but occasionally invents a confident explanation when it encounters unfamiliar information. The second system recognizes uncertainty, explains its limitations and recommends consulting an appropriate professional when the question exceeds its capabilities.

Their accuracy percentages are identical, but their behavior is not equally reliable.

Other measurements can reveal differences that accuracy alone misses:

  • Precision: How often are positive predictions actually correct?
  • Recall: How many relevant positive cases does the system successfully identify?
  • F1 score: How effectively does the system balance precision and recall?
  • Calibration: Does the model's expressed confidence correspond to its actual likelihood of being correct?
  • Robustness: Does performance remain stable when wording, formatting or input conditions change?
  • Consistency: Does the system produce dependable results when a task is repeated?
  • Efficiency: How much time, computing power and money are required?
  • Safety: Does the model avoid unacceptable behavior under difficult or adversarial conditions?

Understanding the difference between precision and recall

These two measurements are particularly useful when evaluating AI systems that classify information.

Imagine an AI system designed to identify suspicious financial transactions. Precision describes how many transactions flagged by the system are genuinely suspicious. Recall describes how many of the genuinely suspicious transactions the system successfully identifies.

A system that flags only a handful of transactions might have excellent precision but poor recall because it misses many problematic cases.

Another system might identify nearly every suspicious transaction but also flag a large number of legitimate purchases.

Neither result alone tells the entire story. The appropriate balance depends on the consequences of false alarms and missed detections.

This example illustrates why a benchmark should be designed around the actual purpose of the AI application.

Why performance involves trade-offs

AI development frequently involves competing objectives. A model may become more accurate when allowed additional reasoning time, but the extra computation can increase latency and cost.

Another model may produce shorter answers and operate more efficiently, while occasionally missing important details. A third may be particularly strong at following instructions but less capable of handling unusual questions.

There is no universal metric that automatically resolves these differences.

Stanford's HELM research emphasizes the importance of evaluating multiple characteristics. Its broader philosophy recognizes that systems can perform differently depending on the scenario and the qualities being measured.

This approach is especially important when evaluating models intended for different purposes. A lightweight assistant designed for mobile devices should not necessarily be judged by exactly the same priorities as an expensive system intended for advanced scientific research.

The correct question is not simply which AI has the highest score. It is which system performs best on the tasks that matter, under conditions that resemble its intended use.

3. The Science of Measurement Uncertainty

One of the most overlooked aspects of AI evaluation is statistical uncertainty. A benchmark score is an estimate based on a particular collection of tasks. It should not automatically be treated as an exact measurement of a model's overall ability.

Suppose a model answers 350 out of 500 questions correctly. Its measured accuracy is 70 percent.

That result is useful, but what would happen if researchers selected a different collection of 500 questions from the same general population of tasks?

The result might be slightly higher or lower. Some questions could be unusually easy, others unusually difficult, and a different selection could favor certain abilities.

Understanding confidence intervals

Statisticians use confidence intervals to communicate uncertainty around an estimated result.

For a simple example, assume an AI model achieves 70 percent accuracy on 500 independent questions. Under a basic binomial approximation, its estimated 95 percent confidence interval is approximately 66 percent to 74 percent.

This calculation is illustrative rather than a complete evaluation analysis. Real benchmark tasks may not be independent, equally difficult or representative of the wider population.

Nevertheless, the example demonstrates why a reported percentage should not be interpreted as an infinitely precise measurement.

When a small difference means very little

Imagine that two AI systems are evaluated on separate samples of 500 comparable questions.

Measurement Model A Model B
Questions evaluated 500 500
Correct answers 350 360
Accuracy 70% 72%
Observed difference 2 percentage points

At first glance, Model B appears to be the winner. But the two-point difference is small relative to the uncertainty associated with these samples.

It would be premature to conclude that Model B is genuinely more capable based only on these figures.

Researchers need to consider sample size, task difficulty, the relationship between individual questions and the statistical method used to compare the systems.

When both models answer the same questions, paired statistical comparisons can be more informative than treating their scores as independent. A paired bootstrap or another appropriate statistical test can examine how consistently one model outperforms the other across the same tasks.

Why larger samples matter

Increasing the number of evaluation tasks generally reduces sampling uncertainty, assuming the additional tasks are relevant and properly selected.

A benchmark containing 5,000 carefully designed questions may provide more stable information than one containing 100 questions. However, simply increasing the number of questions does not automatically produce a trustworthy benchmark.

If thousands of questions all measure the same narrow ability, the evaluation can remain unrepresentative.

Quality, diversity and independence are therefore just as important as quantity.

Task difficulty changes the interpretation

A score of 90 percent on a collection of elementary questions is not necessarily more impressive than a score of 60 percent on exceptionally difficult scientific problems.

Researchers must examine the difficulty distribution and determine whether the evaluation distinguishes between levels of capability.

Benchmarks can also become saturated. When most advanced models answer nearly every question correctly, the examination stops providing much information about differences between them.

This is one reason researchers continuously develop more challenging evaluations. A useful benchmark must remain capable of distinguishing between systems without becoming unfair or impossible.

Statistical significance is not practical significance

Another common misunderstanding is treating statistical significance as proof that an improvement matters in practice.

With a sufficiently large dataset, even a very small performance difference can become statistically detectable.

However, an improvement of a fraction of a percentage point might not justify a major increase in operating costs or response time.

Conversely, a small improvement in detecting a rare but dangerous failure could have considerable practical importance.

Researchers should therefore distinguish three questions:

  1. Is the observed difference likely to be real rather than sampling noise?
  2. Is the difference large enough to matter for the intended application?
  3. Does the improvement justify any additional cost, complexity or risk?

Statistical uncertainty is not a technical footnote. It is part of the evidence required to decide whether an AI system has genuinely improved.

4. The Growing Problem of Benchmark Contamination

Perhaps the most important challenge facing AI evaluation is benchmark contamination.

Modern language models are trained using enormous collections of information. These collections can include books, websites, scientific papers, programming repositories and other publicly accessible material.

Sometimes, information from an evaluation dataset appears in the training material used to develop a model.

This creates a serious measurement problem. A model may perform well partly because it has encountered the examination questions, their answers or closely related examples before.

How contamination happens

Imagine preparing a school examination and accidentally distributing the questions and answer key to students several weeks before the test.

Some students might still need to understand the subject, but they would have an advantage over students who had never encountered the material.

A similar issue can arise with AI models.

When benchmark questions and solutions are publicly available, they may be included in training datasets or reproduced in material used during later training stages.

Contamination does not always mean a model has memorized an entire answer word for word. Exposure to the original problem, solution patterns, relevant documentation or associated discussions can also influence performance.

Researchers therefore need to distinguish genuine generalization from the ability to reproduce information encountered previously.

Why exact text matching is insufficient

One early approach to detecting contamination involves comparing benchmark questions against training datasets using matching phrases or sequences of words.

Although useful, this approach has limitations.

A question can be paraphrased, translated into another language or rewritten while preserving the underlying information. A model may still recognize the problem even when the original wording does not appear in its training data.

A 2023 research paper, Rethinking Benchmark and Contamination for Language Models with Rephrased Samples, examined this problem.

The researchers demonstrated that simple variations of benchmark examples could bypass certain string-matching decontamination methods. They also identified substantial overlap between the HumanEval coding benchmark and some publicly available training datasets they examined.

Their findings highlighted why detecting contamination requires more sophisticated methods than searching for identical text.

Why public software repositories create additional risks

Software engineering benchmarks present a particularly difficult problem because many tasks originate from public GitHub repositories.

These repositories contain code, bug reports, discussions, documentation and completed fixes. They are valuable sources of realistic programming tasks, but they can also appear in the material used to train coding models.

Imagine asking a coding model to solve an old bug report. If the model has already encountered the original solution during training, it may reproduce the relevant code without independently discovering the correct approach.

The final code could pass every test, but the result would provide weaker evidence of the model's ability to solve unfamiliar programming problems.

This distinction matters because the objective of a benchmark is not simply to determine whether the model can produce an answer. It is to measure the capability that the benchmark claims to represent.

How researchers can reduce contamination

There is no perfect solution, but several strategies can improve benchmark integrity.

  • Keep some evaluation questions private.
  • Create fresh tasks that did not exist when earlier models were trained.
  • Separate training, development and final testing datasets.
  • Use controlled access to sensitive evaluation material.
  • Investigate suspiciously strong performance on individual questions.
  • Test models on variations of familiar problems.
  • Report known contamination risks alongside benchmark results.
  • Refresh evaluation sets when public material becomes too familiar.

Private evaluations also have disadvantages. They may be harder for independent researchers to reproduce and scrutinize.

A trustworthy evaluation ecosystem therefore needs a balance between transparency and protecting test material from becoming part of future training data.

5. When the Examination Itself Is Broken

Contamination is only one side of the benchmark problem. Sometimes the examination itself contains mistakes.

A benchmark can produce misleading results even when the AI model has never encountered its questions before.

This happens when questions are ambiguous, scoring systems are incorrect, expected answers are too restrictive or testing environments behave unpredictably.

False negatives: rejecting correct answers

Imagine asking an AI coding agent to repair a calculator application. The instructions say that the application should correctly calculate percentages.

The model produces a working solution, and independent testing confirms that the requested functionality operates correctly.

However, the benchmark expects a particular internal function name that was never mentioned in the instructions.

The model's solution fails the hidden test, even though the application works correctly.

This is a false negative: the evaluation labels a correct or acceptable solution as unsuccessful.

False positives: rewarding incomplete answers

The opposite problem also occurs.

Suppose a benchmark asks a coding agent to repair a security vulnerability. The model makes a superficial change that passes the available tests but does not actually eliminate the underlying security weakness.

The benchmark records success, even though the software remains vulnerable.

This is a false positive: an incorrect or incomplete solution receives a passing score.

Ambiguous instructions create unfair comparisons

Consider a task asking an AI system to improve the performance of a website.

Does the task mean reducing the initial loading time, improving database queries, lowering server costs or making the interface respond faster to user interactions?

All these interpretations might be reasonable.

If the evaluation secretly expects only one specific implementation, a model can fail despite producing a valid improvement.

Ambiguity also affects comparisons between different models. One system might infer the intended requirement correctly, while another might choose a different but equally reasonable interpretation.

The resulting score could reflect the benchmark's wording rather than a genuine difference in technical capability.

Hidden tests need careful validation

Hidden tests are useful because they prevent models from simply copying visible answers or optimizing exclusively for known examples.

However, hidden tests must still represent the actual task requirements.

Good software evaluation should check both whether the requested functionality works and whether existing functionality remains intact.

It should also avoid enforcing irrelevant implementation details.

In other words, the test must distinguish a genuinely incorrect solution from an alternative solution that achieves the same legitimate objective.

Human reviewers, independent test environments and detailed scoring audits are important safeguards against these problems.

6. The SWE-bench Controversy: A Real-World Case Study

The development of SWE-bench provides one of the clearest examples of how an influential AI benchmark can lose reliability and why researchers must continuously reassess their measurement systems.

What is SWE-bench?

SWE-bench was introduced as a way to measure whether AI systems could resolve real software engineering issues.

Instead of asking a model to write a small programming function from scratch, the benchmark gives it an existing software repository and a problem description based on an actual GitHub issue.

The model must understand the project, locate the relevant code, implement a modification and produce a solution that passes the evaluation tests.

The original benchmark included problems from established open-source Python repositories. Its task structure was more realistic than many traditional coding examinations because it required understanding an existing codebase rather than solving isolated algorithmic questions.

Why SWE-bench Verified was created

The original SWE-bench contained tasks with problems such as ambiguous instructions, unreliable test environments and evaluation rules that could reject valid solutions.

In August 2024, OpenAI introduced SWE-bench Verified, a curated subset of 500 tasks selected after human review.

According to its documentation, 1,699 original problems were reviewed by three experts independently. The review process was intended to remove examples that were impossible or unfair to evaluate.

The benchmark subsequently became an important reference point for comparing AI coding agents.

However, its apparent improvement did not eliminate every underlying weakness.

OpenAI's February 2026 audit

On February 23, 2026, OpenAI published Why SWE-bench Verified No Longer Measures Frontier Coding Capabilities.

The company reported two major problems.

First, it examined 138 difficult problems that its o3 model did not consistently solve across 64 independent runs. Each case was reviewed by at least six experienced software engineers, with additional verification when necessary.

Of those 138 audited tasks, 59.4 percent contained material problems involving the test design or problem description.

This figure needs careful interpretation. It refers to the selected group of 138 difficult tasks, not to 59.4 percent of the entire 500-question benchmark.

The audit identified several kinds of problems:

  • Overly narrow tests: Some tests required specific implementation details that were never included in the original instructions.
  • Overly broad tests: Other tests demanded functionality beyond what the task description requested.
  • Other evaluation problems: Some examples contained additional issues affecting whether a solution could be judged fairly.

Second, OpenAI reported evidence that frontier models had encountered some benchmark problems and solutions during training.

Its analysis found that tested models could reproduce original human-written fixes or specific details of certain problem statements.

OpenAI concluded that improvements on SWE-bench Verified increasingly reflected exposure to benchmark material rather than meaningful improvements in real-world coding ability.

The company consequently stopped reporting its frontier coding results on SWE-bench Verified and recommended that other developers do the same.

Why SWE-bench Pro also faced criticism

OpenAI recommended SWE-bench Pro as a more challenging and less contaminated alternative.

The newer benchmark was designed to evaluate longer software engineering tasks using more complex repositories and realistic development environments.

However, the replacement soon faced its own quality concerns.

On July 8, 2026, OpenAI published another audit examining the public 731-task SWE-bench Pro dataset.

An automated data-quality pipeline flagged 200 tasks, representing 27.4 percent of the public set. A separate human annotation campaign identified 249 tasks, or 34.1 percent.

The review identified four principal problem categories:

  1. Tests that were too strict and rejected functionally correct implementations.
  2. Instructions that omitted requirements enforced by hidden tests.
  3. Tests that did not adequately verify the requested functionality.
  4. Misleading instructions that pointed models toward behavior inconsistent with the tests.

These findings are particularly revealing because SWE-bench Pro had been recommended as an alternative to an earlier benchmark with similar weaknesses.

Independent scrutiny also mattered. Epoch AI's September 1, 2026 review designated the original SWE-bench Pro evaluation as flawed, citing multiple audits and concerns about task quality and scoring.

This was an independent assessment of the benchmark version reviewed at that time, not a final judgment on every subsequent revision.

The September 2026 SWE-bench Pro V2 release

On September 22, 2026, Scale AI released SWE-bench Pro V2, a refreshed public evaluation set with a modified benchmark and a locked evaluation protocol.

The new public version contains 642 tasks across 11 repositories, compared with the previous public collection of 731 tasks.

Scale AI reported that 89 tasks had been removed following review. It also described changes intended to improve evaluation integrity.

Among the reported changes were:

  • Correcting wording in 69 tasks where instructions contradicted the tests.
  • Disabling web tools during the agent evaluation phase.
  • Re-grading agent modifications in a clean environment.
  • Introducing a two-sided validation process requiring the reference solution to pass and the unmodified solution to fail.
  • Publishing additional evaluation trajectories and grading information.

Scale AI also disclosed remaining limitations, including aspects of the model endpoint and execution of code contained in submitted patches.

The release demonstrates that benchmark creators can respond to criticism with meaningful changes. Nevertheless, a revised benchmark still needs independent testing and continued quality monitoring.

What this case study teaches the AI industry

The SWE-bench experience illustrates several important principles.

A benchmark can become influential before every possible weakness has been identified. Human review can improve a dataset without guaranteeing that all problems have disappeared. A proposed replacement can also contain flaws. Finally, publishing a revised version is not the same as proving that the new evaluation is permanently reliable.

It is also a reminder that the organizations creating, selling and evaluating AI systems have different incentives. Independent audits provide an essential additional perspective.

The most useful benchmark is not necessarily the one with the largest collection of questions or the most impressive leaderboard. It is the one whose methodology can withstand careful scrutiny.

7. Moving From Examination Questions to Real-World Work

Traditional AI benchmarks often use short questions with clearly defined answers. This makes automatic scoring relatively easy.

However, most professional activities are not collections of isolated questions.

A software developer might spend several hours understanding an unfamiliar project, locating a problem, testing different solutions and documenting the final changes. A financial analyst might collect data from multiple sources, build a spreadsheet, identify inconsistencies and prepare a presentation.

These tasks require more than producing a correct sentence.

Why real-world tasks are harder to measure

Professional work frequently involves incomplete information, competing objectives and changing requirements.

A successful result may also require several stages of interaction. A first draft might be technically correct but poorly organized. A second draft might improve the presentation but introduce an error. The final result could depend on feedback from another person.

A benchmark that evaluates only the first response cannot fully represent this process.

Real-world evaluation should therefore consider factors such as:

  • Whether the system understands the actual objective.
  • Whether it can identify missing information.
  • Whether it uses tools appropriately.
  • Whether it checks its own work.
  • Whether it can recover from mistakes.
  • Whether the final deliverable meets professional requirements.
  • How much human supervision is necessary.
  • Whether the result is produced at an acceptable cost and speed.

GDPval: measuring economically valuable tasks

One example of a more practical evaluation approach is GDPval, an OpenAI benchmark introduced in September 2025 to measure AI performance on real-world economically valuable tasks.

Its first version covers 44 occupations across nine major economic sectors. The full dataset contains 1,320 specialized tasks, including an open-source gold set of 220 tasks.

Experienced professionals helped develop and review the tasks, averaging more than 14 years of professional experience.

Unlike a conventional examination, GDPval includes practical deliverables such as documents, spreadsheets, diagrams, presentations and other work products.

For example, an evaluation might ask a model to prepare a professional document using reference files and supporting information rather than simply answering a question about the subject.

Experienced professionals then compare AI-generated work against deliverables produced by human task writers. The comparisons are conducted blindly, meaning the graders are not told which output came from the AI system.

They assess the deliverables and classify the AI work according to whether it is better than, as good as or worse than the human-produced comparison.

Why GDPval is more realistic but not perfect

GDPval represents an important shift because it evaluates completed work rather than only isolated knowledge questions.

However, its creators acknowledge important limitations.

The initial evaluation uses one-shot tasks. It does not fully represent situations in which a professional must clarify requirements, build context, revise work after feedback or respond to changing information.

For example, preparing a legal document may require several conversations with a client. Producing a financial analysis may require discovering that an important dataset is incomplete and deciding how to proceed.

These activities cannot always be represented by one carefully written prompt.

GDPval is therefore a more realistic measurement tool for certain professional tasks, but it should not be interpreted as proof that an AI model can independently perform every responsibility associated with the occupations it covers.

Measuring the entire workflow

Another important development is the evaluation of AI systems across extended tasks.

Consider an AI assistant asked to prepare a research report. The process may involve searching for information, collecting documents, checking sources, organizing evidence, drafting sections and reviewing the final result.

A benchmark that scores only the final text might overlook the time spent retrieving information, the reliability of the sources or the number of corrections needed.

A stronger evaluation examines the entire process.

This includes whether the AI system selected appropriate sources, recognized conflicting information, preserved important details and produced a result that a human reviewer could actually use.

Such evaluations provide a more meaningful picture of practical AI capability.

8. Why Human Evaluation Still Matters

Automatic scoring is attractive because it is fast, inexpensive and relatively easy to reproduce. A computer can determine whether a mathematical answer matches a reference value or whether a programming test passes.

But many AI outputs are difficult to judge through exact matching.

Consider a request to write a customer-service response. Several different answers may be correct, and the quality of the response may depend on tone, clarity, completeness and whether it addresses the customer's actual concern.

Human evaluation can help identify these differences.

Blind comparison reduces certain biases

In a blind evaluation, graders do not know which answer came from which model.

They may compare two responses and determine which is more accurate, useful, readable or complete.

This reduces the risk that brand recognition or expectations about a particular AI company will influence the decision.

However, blind evaluation does not eliminate every source of bias.

Grader preferences can vary. One person may value concise writing, while another prefers extensive explanations. A technical expert may prioritize correctness, whereas an ordinary user may focus on convenience.

Inter-rater reliability

When several people evaluate the same outputs, researchers can examine whether their judgments agree.

This is commonly called inter-rater reliability.

If graders consistently reach similar conclusions, researchers gain more confidence that the evaluation criteria are understandable and reasonably stable.

If judgments vary considerably, the researchers may need clearer scoring instructions, better training or a different evaluation method.

For subjective tasks, relying on one evaluator can be particularly risky.

Why detailed scoring rubrics matter

A scoring rubric defines the characteristics that evaluators should consider.

For example, a benchmark evaluating AI-generated business reports might use separate criteria for:

  • Factual accuracy and numerical correctness.
  • Completeness of the requested analysis.
  • Quality and relevance of supporting evidence.
  • Organization and readability.
  • Professional presentation.
  • Compliance with the original instructions.

This makes the evaluation more transparent than asking graders to select whichever document they personally prefer.

It also helps identify why a model performed well or poorly. A system might produce excellent formatting while making several factual errors, or deliver accurate information in a confusing structure.

AI judges have limitations too

Another developing approach uses one AI model to evaluate the responses of another.

This is often called model-based evaluation or LLM-as-a-judge.

An AI judge can compare responses, apply a scoring rubric and provide structured feedback. This can reduce the cost of large evaluation campaigns.

However, AI judges can make mistakes. They may favor longer answers, prefer certain writing styles or overlook subtle factual errors.

They may also share weaknesses with the systems they evaluate.

For this reason, AI-generated evaluations should be calibrated against human judgments, especially when the results influence important decisions.

OpenAI's GDPval methodology provides a useful example. Its published approach uses experienced professional graders for blind comparisons and explicitly distinguishes its experimental automated grading system from expert evaluation. The company states that the automated grader is not yet sufficiently reliable to replace human graders.

The broader lesson is that human judgment remains essential wherever quality cannot be reduced to a simple, objective answer.

9. Reproducibility and the Importance of Repeated Testing

Imagine asking an AI model the same question five times and receiving five slightly different answers.

This is not necessarily evidence of a malfunction. Generative AI systems can produce different outputs depending on sampling settings, context, system instructions and other factors.

However, this variability creates an important question: how dependable is a benchmark result when the same model can perform differently across repeated attempts?

Repeatability versus reproducibility

These concepts are related but distinct.

Repeatability concerns whether the same evaluation procedure produces consistent results under similar conditions.

Reproducibility concerns whether other researchers can obtain comparable results when they repeat the experiment using sufficiently documented methods and conditions.

For AI evaluations, reproducibility requires more than publishing a final percentage.

Researchers should document the model version, prompt, sampling settings, available tools, number of attempts, scoring procedure and other relevant experimental conditions.

Why model versions matter

AI services can change over time. A provider may update a model, modify its system instructions or change the infrastructure supporting its responses.

Two people using a product with the same public-facing name may therefore not necessarily be evaluating precisely the same underlying system.

Version identification is important when comparing results across different dates.

For example, an evaluation conducted in January may use one model snapshot, while a second evaluation in April may use an updated version. Without clear documentation, researchers could mistakenly attribute performance changes to the wrong cause.

Repeated trials reveal unstable performance

Researchers can repeat benchmark tasks using different random seeds or controlled sampling settings.

They can then examine whether the model consistently succeeds or whether its performance depends heavily on chance.

This matters particularly for complex tasks that involve multiple reasoning stages, external tools or long interactions.

A system that succeeds once in ten attempts may have a very different practical value from one that succeeds nine times in ten, even if both can produce an impressive successful demonstration.

Why average performance can hide important failures

Imagine two AI systems evaluated on 100 tasks.

Both achieve an overall success rate of 90 percent. However, the first fails on ten unrelated tasks, while the second fails on ten tasks that all involve the same critical security requirement.

Their overall scores are identical, but their risk profiles are very different.

Researchers should therefore examine failure patterns, not just average results.

This is particularly important for applications in which one serious failure could outweigh dozens of successful routine tasks.

METR and the measurement of longer tasks

Another interesting approach comes from METR, a research organization studying the capabilities of advanced AI systems.

Its task-completion time horizon research examines how the duration of tasks completed by human experts relates to an AI agent's probability of completing those tasks.

The concept is useful because completing a five-minute task is not equivalent to independently completing a project that takes an expert several hours.

METR's September 8, 2026 measurement page describes an evaluation using more than 100 software-related tasks, including software engineering, machine learning and cybersecurity work.

Its methodology estimates how long human experts take to complete each task and fits a statistical curve to the probability that an AI agent succeeds at different task durations.

It reports different reliability thresholds, including estimated 50 percent and 80 percent success time horizons.

Importantly, METR states that measurements above 16 hours are unreliable with its current task suite. Its task collection also does not represent every type of professional work.

The distinction matters because a two-hour task-completion horizon does not mean an AI can independently perform every two-hour human activity. The result applies to the particular tasks, conditions and reliability assumptions used in the evaluation.

Time-horizon evaluations demonstrate how researchers can measure something more meaningful than isolated answer accuracy while still acknowledging the limits of their evidence.

10. How Researchers Design More Reliable AI Benchmarks

Creating a trustworthy benchmark requires considerably more work than collecting questions and calculating correct answers.

Researchers must first determine what they want to measure, then develop suitable tasks, establish scoring rules and test the evaluation itself.

Step one: define the capability

The first requirement is a clearly defined research objective.

A benchmark intended to measure mathematical reasoning should not accidentally become a test of reading speed or familiarity with a particular writing style.

Similarly, an evaluation of software engineering should measure whether a proposed solution actually resolves the underlying problem rather than whether it follows one preferred coding convention.

The capability must be defined precisely enough to guide task selection and scoring.

Step two: select representative tasks

A benchmark should include tasks that reflect the range of situations relevant to its intended purpose.

For a multilingual language model, an English-only examination may provide incomplete evidence. For an AI coding assistant, testing only small algorithmic problems may fail to represent the complexity of maintaining a real application.

Researchers should consider different levels of difficulty, domains, languages and task structures.

They should also document what the benchmark does not cover.

Step three: establish fair scoring rules

Every task needs a scoring procedure that accurately reflects the desired outcome.

For objective questions, this might involve exact answers or predefined acceptable alternatives.

For programming tasks, it may involve unit tests, integration tests, security checks and human review.

For professional deliverables, scoring may involve a detailed rubric covering factual accuracy, completeness, clarity and practical usefulness.

The scoring system should avoid rewarding superficial similarities while rejecting genuinely correct alternatives.

Step four: validate the benchmark with people

Human experts can identify ambiguous instructions, broken tests and unrealistic tasks.

They can also attempt the same problems to establish whether the tasks are feasible and whether the expected solutions are reasonable.

This process is particularly valuable in specialized fields where automated scoring cannot easily determine whether an answer is professionally acceptable.

Step five: establish meaningful baselines

A benchmark becomes more informative when researchers compare AI performance against meaningful reference points.

These may include human performance, earlier AI systems, simpler automated methods or established professional tools.

Human baselines require careful design. Researchers should specify who the participants are, how much time they receive and what resources they can use.

Comparing an AI model with an experienced professional who has access to extensive resources is not necessarily fair if the AI receives only a short prompt and a limited time allowance.

Researchers should also distinguish between novice, intermediate and expert human performance where appropriate.

Step six: test for contamination

Benchmark developers should investigate whether evaluation material may have appeared in training datasets.

They can use private test sets, fresh problems, controlled access and specialized contamination-detection procedures.

They should also consider whether models can obtain answers through external tools during evaluation.

Step seven: test the testing environment

A benchmark can contain good questions and still produce unreliable results if its software environment is inconsistent.

For example, a programming task may behave differently depending on the operating system, dependency versions or available hardware.

Researchers should use reproducible environments, document dependencies and test whether reference solutions consistently pass.

They should also test empty or unmodified solutions where appropriate to establish that the evaluation can distinguish a genuine repair from an unchanged codebase.

Step eight: publish the methodology

Independent researchers need enough information to understand and reproduce an evaluation.

A useful benchmark report should include:

  • The benchmark's intended purpose.
  • The number and type of evaluation tasks.
  • The task-selection methodology.
  • The model versions tested.
  • The prompts and system configurations.
  • The tools and computing resources available.
  • The scoring methodology.
  • Statistical uncertainty and known limitations.
  • Information about potential data contamination.
  • Relevant raw results and reproducibility materials.

Stanford HELM's emphasis on prompt-level transparency and reproducibility demonstrates the importance of making evaluation procedures inspectable rather than publishing only aggregated scores.

These principles also align with the broader risk-management approach in the National Institute of Standards and Technology's Generative Artificial Intelligence Profile, NIST AI 600-1.

Published on July 26, 2024, the document provides guidance for incorporating trustworthiness considerations throughout the generative AI lifecycle. It addresses risks that organizations should consider when designing, developing, evaluating and deploying generative AI systems.

The broader message is that testing and evaluation should be integrated into responsible AI development rather than treated as a one-time public-relations exercise.

11. How to Read AI Leaderboards Without Being Misled

AI leaderboards are useful because they organize performance information and allow readers to compare competing systems.

However, a leaderboard can become misleading when readers interpret its ranking without examining the evaluation behind it.

A first-place position is meaningful only in relation to the tasks, scoring rules and conditions used to produce it.

Check the benchmark name and version

Start by identifying the exact benchmark and its version.

Two leaderboards may use similar names but different task collections, scoring procedures or testing environments.

Even different versions of the same benchmark may not be directly comparable.

The SWE-bench experience illustrates this problem particularly well. SWE-bench Verified, the original SWE-bench Pro and SWE-bench Pro V2 should not be treated as interchangeable evaluations.

Check the evaluation date

AI systems develop rapidly, and model providers may release updates that affect performance.

Look for the date of the actual evaluation rather than relying only on the date of the announcement.

A result published recently might use an older model snapshot or a benchmark that has not been updated for several months.

Examine the scoring methodology

Ask whether the score represents exact accuracy, partial credit, human preference, task completion or a combination of measurements.

These methods answer different questions.

A 75 percent accuracy score should not be directly compared with a 75 percent human-preference win rate unless the methodology establishes that the metrics are genuinely comparable.

Look beyond the overall ranking

Aggregate scores can hide important weaknesses.

A model may achieve an impressive overall result because it performs exceptionally well on several common tasks, while struggling with rare but important situations.

Look for category-level results, failure examples and performance across different difficulty levels.

Check whether the comparison is fair

Models should ideally receive equivalent prompts, time limits, tool access and computational resources when the objective is to compare the underlying systems.

When researchers deliberately test complete AI applications with different tools, those differences should be clearly disclosed.

Without this information, it can be difficult to identify the reason one system achieved a higher score.

Understand the role of the testing framework

For agentic AI benchmarks, the software framework surrounding the model can significantly influence performance.

One agent might receive a sophisticated planning system, automatic code execution and error-recovery mechanisms. Another might operate with fewer tools and less opportunity to retry.

Both systems might use powerful underlying models, but their results are not necessarily direct comparisons of model quality.

Readers should look for information about the agent framework, tool permissions, maximum interaction steps, reasoning budgets and execution limits.

Distinguish a win from a statistically meaningful win

A leaderboard may place one model above another even when the observed difference is too small to establish a reliable performance advantage.

Look for confidence intervals, uncertainty estimates and appropriate statistical comparisons.

If two systems have nearly identical results, it may be more accurate to describe them as statistically indistinguishable on that evaluation than to declare one the definitive winner.

Finally, remember that benchmarks can reward different strategies. A system optimized for a specific evaluation may not perform equally well when the task wording, available information or working environment changes.

12. Why Accurate AI Measurement Matters to Businesses

Benchmarking is not simply an academic exercise. Its results increasingly influence business decisions.

Companies evaluate AI products before integrating them into customer support, software development, marketing, research, administration and data analysis.

A misleading benchmark can therefore create financial costs, operational problems and unnecessary security risks.

The danger of buying based on rankings

Imagine a company choosing an AI coding assistant because it ranks first on a popular programming benchmark.

After deployment, the company discovers that the system struggles with its internal software, produces unreliable changes or requires constant supervision.

The benchmark may have measured a legitimate capability, but it did not establish that the product was appropriate for that particular workplace.

This is why businesses should conduct their own evaluations using representative internal tasks whenever possible.

Measure the entire workflow

Businesses should examine more than whether an AI model produces a correct answer.

They should measure how much time employees spend reviewing its work, correcting errors and integrating the output into existing systems.

For example, an AI tool might generate a report in two minutes, but an employee may need another 30 minutes to verify its sources and correct inaccuracies.

Another tool may take slightly longer to generate the report but require much less human editing.

The second system could deliver greater practical value despite appearing slower in a simple response-time benchmark.

Calculate cost per successful task

AI performance must also be evaluated against its operating cost.

Relevant expenses can include API usage, computing resources, subscriptions, integration, employee training and human supervision.

A powerful model that requires repeated attempts to complete routine tasks may be less economical than a smaller system that performs reliably on the same workload.

Businesses should calculate the cost per successfully completed task rather than focusing exclusively on the price of an individual AI response.

A useful simplified formula is:

Cost per successful task = Total evaluation and operating cost divided by the number of tasks completed to the required standard.

This calculation should include meaningful human review costs where applicable.

Evaluate failures, not just successes

It is easy to demonstrate an AI system's capabilities using carefully selected examples.

Businesses should also investigate what happens when the model encounters unfamiliar information, conflicting instructions, incomplete data or unusual user requests.

Failure analysis can reveal weaknesses that an overall success rate conceals.

For high-impact applications, organizations should establish clear human-review requirements, escalation procedures and monitoring systems before deployment.

Consider privacy and security

A high-performing AI system may still be unsuitable for a business if its data-handling practices do not meet the organization's requirements.

Companies should examine how information is processed, whether sensitive documents are retained, what access controls exist and whether external tools introduce additional risks.

They should also test for prompt injection, unauthorized data exposure and other weaknesses relevant to their workflows.

These considerations are part of evaluating the complete AI product rather than judging its underlying model alone.

13. The Future of AI Evaluation: What Comes Next?

The limitations of traditional benchmarks are encouraging researchers to explore more realistic, continuous and comprehensive methods of measuring artificial intelligence.

Rather than depending on one examination administered once, future evaluation systems are likely to combine several complementary approaches.

Dynamic benchmarks with fresh tasks

Static benchmarks eventually become familiar to the AI community.

As models improve and publicly available test material spreads, the ability of a fixed examination to distinguish genuine generalization becomes weaker.

Dynamic benchmarks attempt to address this problem by regularly introducing fresh tasks.

Research presented at NeurIPS 2025 introduced SWE-rebench, an automated pipeline for collecting new software engineering tasks from GitHub repositories.

The research describes a public dataset containing more than 21,000 interactive Python-based software engineering tasks and a process for creating fresh evaluations that reduce contamination risks.

Its authors compared performance on their newer evaluation with SWE-bench Verified and reported evidence that contamination could inflate the apparent performance of some language models.

Dynamic testing introduces its own challenges. New tasks must still be checked for quality, difficulty and consistency. A continuously updated benchmark is not automatically a fair benchmark.

Private and one-time examinations

Another approach involves keeping some evaluation questions private or using one-time tests that are not publicly distributed.

These examinations can reduce the likelihood that their questions and answers become part of future training datasets.

However, private testing creates a transparency problem. Other researchers may not be able to inspect the questions or independently verify the results.

A practical compromise is to publish detailed methodologies, release selected public examples and allow trusted independent evaluators to examine protected test material.

Long-horizon evaluations

Many professional tasks require several hours or days of coordinated work.

Future evaluations will increasingly examine whether AI agents can maintain context, use tools correctly, recover from failures and deliver complete results across extended workflows.

This is a different challenge from answering a question correctly in a single interaction.

Long-horizon testing can also reveal problems that remain invisible during short demonstrations, such as accumulating errors, losing track of requirements or making costly decisions without sufficient verification.

More realistic human-AI collaboration

AI systems are increasingly used as collaborators rather than isolated question-answering tools.

Researchers will need to measure how well they respond to feedback, request clarification, communicate uncertainty and work alongside human professionals.

A useful assistant should not simply produce an answer. It should also understand when additional information is necessary and when a human decision is required.

Consider a design task in which a client initially requests a website but later explains that the real objective is to increase online bookings.

A capable AI system should be able to recognize that the original request may need reconsideration, ask relevant questions and adapt its proposed solution.

Evaluations that measure only whether the model follows the first instruction would miss this important ability.

Better measurement of uncertainty

Researchers are also examining how consistently models respond to repeated tasks and how uncertainty can be quantified.

Future evaluations may increasingly measure whether models can recognize when they lack enough information, distinguish uncertain claims from established facts and avoid presenting unsupported conclusions with excessive confidence.

This is particularly important for research, education, legal work and scientific applications.

A system that can acknowledge uncertainty may be more useful than one that produces confident answers regardless of the available evidence.

Safety evaluations throughout the development process

Capability is only one part of responsible AI development.

Organizations also need to investigate whether systems behave safely when faced with malicious instructions, sensitive information, adversarial inputs and unfamiliar situations.

The NIST Generative AI Profile provides a framework for considering risks throughout the AI lifecycle.

Future evaluation programs will likely place greater emphasis on continuous testing, monitoring and reassessment after deployment.

As AI systems become more capable and are given access to more tools, the consequences of evaluation mistakes could become more significant.

The future of AI benchmarking will therefore depend not only on designing harder tests but also on building more trustworthy measurement systems.

14. A Practical Checklist for Evaluating AI Claims

You do not need to be a machine-learning researcher to examine an AI benchmark critically. A few questions can help you determine whether a performance claim deserves confidence.

For ordinary users

  • What specific ability does the benchmark measure?
  • Is the result based on real tasks or simple examination questions?
  • Does the evaluation include independent testing?
  • Is the score meaningfully higher than competing models?
  • Does the system perform consistently across different attempts?
  • Are its weaknesses and limitations disclosed?
  • Does the benchmark resemble the tasks you actually want to perform?
  • Does the evaluation test the model alone or a complete AI application?

For developers

  • Use multiple benchmarks rather than relying on one score.
  • Maintain private or freshly created evaluation tasks.
  • Test models using representative real-world scenarios.
  • Repeat evaluations to estimate variability.
  • Document prompts, versions, sampling settings and tools.
  • Use human reviewers when automatic scoring is insufficient.
  • Examine failures and edge cases individually.
  • Report uncertainty and known benchmark limitations.
  • Validate the testing environment before interpreting model failures.

For businesses choosing an AI product

  • Test the product using actual workplace tasks.
  • Measure the time saved after human review.
  • Calculate the cost per successful task.
  • Evaluate privacy, security and data-handling requirements.
  • Measure how often employees must correct its work.
  • Compare performance against existing human workflows.
  • Run a pilot before making large-scale deployment decisions.
  • Establish clear procedures for handling serious failures.

A simple example: testing two AI assistants

Suppose a small business wants to choose between two AI assistants for preparing product descriptions and customer-service responses.

Instead of relying on public leaderboard rankings, the business creates a private collection of 100 representative tasks based on its actual products and customer questions.

Both assistants receive the same instructions and reference information. Their outputs are reviewed without revealing which system generated each response.

The reviewers assess accuracy, completeness, clarity, compliance with company requirements and the amount of editing necessary.

The business also records response time, operating costs and the frequency of serious mistakes.

Imagine that Assistant A produces more polished initial responses but requires extensive factual corrections. Assistant B produces slightly less polished drafts but consistently uses the correct product information.

If the business values accuracy and lower review time, Assistant B might be the better choice even if Assistant A ranks higher on a general writing benchmark.

This is a practical demonstration of why task-specific testing can be more valuable than a universal ranking.

The objective is not to reject benchmarks. It is to understand what they can legitimately demonstrate and where additional evidence is necessary.

A well-designed benchmark can reveal important capabilities, expose weaknesses and guide technological development. A poorly interpreted benchmark can create an exaggerated picture of progress.

Frequently Asked Questions About AI Benchmarks

1. What is an AI benchmark?

An AI benchmark is a standardized collection of tasks used to evaluate the performance of artificial intelligence systems. It can measure capabilities such as reasoning, mathematical problem-solving, programming, instruction following, language understanding, safety and efficiency. Researchers use benchmark results to compare models under defined testing conditions.

2. Why are AI benchmark scores sometimes misleading?

Scores can be misleading when benchmarks contain flawed questions, incorrect scoring rules, contaminated training data or tasks that do not represent real-world situations. A high score may demonstrate strong performance on a particular examination without establishing that the model is generally more capable or reliable.

3. What is benchmark contamination in artificial intelligence?

Benchmark contamination occurs when evaluation questions, answers or related information appear in the training material used to develop an AI model. This exposure can improve performance without necessarily demonstrating genuine generalization to unfamiliar problems.

4. What is the difference between AI accuracy and reliability?

Accuracy measures how frequently a system produces correct results on an evaluation set. Reliability concerns whether the system continues to perform dependably across different situations, repeated attempts and changing conditions. A model can have high measured accuracy but still behave inconsistently or fail in important edge cases.

5. What is a confidence interval in AI benchmarking?

A confidence interval is a statistical range that communicates uncertainty around an estimated measurement. It helps researchers understand how much a benchmark result might vary because of the particular tasks selected. Confidence intervals are especially useful when comparing models with similar scores.

6. Is a model with the highest AI benchmark score always the best?

No. A model may lead on one benchmark while performing less effectively on another. Its suitability depends on the intended application, task difficulty, accuracy, consistency, safety, latency, cost and available tools. Different systems can be better choices for different requirements.

7. What is SWE-bench Verified?

SWE-bench Verified is a collection of 500 human-reviewed software engineering problems designed to evaluate AI systems' ability to resolve real GitHub issues. It became an important coding benchmark after its introduction in August 2024. OpenAI announced in February 2026 that it had stopped using it to measure frontier coding capabilities because of contamination and evaluation-quality problems.

8. Why did SWE-bench Verified become controversial?

Researchers identified problems involving publicly available benchmark material that could appear in model training datasets. They also found that some tests rejected functionally correct code or required implementation details that were not adequately specified. These issues weakened the reliability of its scores as a measurement of frontier coding capabilities.

9. What is SWE-bench Pro V2?

SWE-bench Pro V2 is a refreshed public version of the SWE-bench Pro software engineering benchmark, released by Scale AI on September 22, 2026. It contains 642 tasks across 11 repositories and introduces changes to task validation, evaluation environments and testing protocols. It is designed to improve the reliability of software engineering agent evaluations.

10. What is the difference between an AI benchmark and a real-world evaluation?

A traditional benchmark generally measures performance on a defined set of standardized tasks. A real-world evaluation attempts to represent practical activities, including complex workflows, incomplete information, tool usage, collaboration and professional-quality deliverables. Both approaches are useful, but they answer different questions.

11. Why do researchers use human graders to evaluate AI?

Human graders are valuable when there is no single objectively correct answer. They can evaluate qualities such as usefulness, clarity, professional judgment and completeness. Blind comparisons and multiple independent reviewers can reduce certain biases and improve confidence in subjective evaluations.

12. Can one AI model evaluate another AI model?

Yes. This approach is commonly called LLM-as-a-judge. An AI evaluator compares responses or applies a scoring rubric. It can make large-scale evaluation faster and less expensive, but its judgments can contain biases and mistakes. Human validation remains important, particularly for high-impact applications.

13. What is the HELM evaluation framework?

HELM, developed by Stanford University's Center for Research on Foundation Models, is a framework for holistic and reproducible evaluation of language models. Its original research examined 16 core scenarios and seven metrics. It considers multiple dimensions of model performance rather than relying only on accuracy.

14. What is GDPval?

GDPval is an AI evaluation benchmark introduced by OpenAI in September 2025. Its first version assesses model performance on practical professional tasks covering 44 occupations across nine economic sectors. Its methodology includes blind comparisons between AI-generated deliverables and work produced by human professionals.

15. How does METR measure AI task-completion capabilities?

METR estimates how long human experts take to complete selected tasks and examines the probability that AI agents can complete those tasks successfully. Its time-horizon methodology uses statistical curves to estimate the task duration associated with different success probabilities. Its measurements are limited to the task categories and testing conditions included in its evaluation.

16. How can businesses choose the best AI model?

Businesses should test AI products using tasks that resemble their actual operations. They should measure accuracy, reliability, human supervision, time savings, operating costs, privacy and security. A model that performs best on a public leaderboard is not automatically the best option for a particular business.

17. Will AI benchmarks become more reliable in the future?

They can become more reliable through better task design, independent audits, contamination-resistant evaluations, statistical analysis, repeated testing and realistic professional scenarios. However, no benchmark can capture every aspect of intelligence or guarantee future performance. Continuous evaluation will remain necessary as AI capabilities evolve.

Conclusion: Measuring AI Progress Requires More Than Impressive Numbers

The artificial intelligence industry is entering a stage in which measuring capabilities is becoming almost as important as developing them.

As AI models become more sophisticated, traditional examinations can lose their ability to distinguish genuine improvements. Public datasets may become contaminated, automated tests may reject valid solutions, and small differences in leaderboard scores may reflect statistical uncertainty rather than meaningful progress.

The experiences surrounding SWE-bench Verified and the subsequent debates over SWE-bench Pro demonstrate that even widely recognized evaluations require continuous scrutiny. The September 2026 release of SWE-bench Pro V2 also shows how benchmark creators can respond to criticism by revising their datasets and testing procedures.

Meanwhile, approaches such as Stanford HELM, professional task evaluations and METR's task-completion research show how measurement can expand beyond simple question-and-answer testing.

For consumers, this means looking beyond marketing claims and understanding what a reported score actually represents. For developers, it means designing evaluations that are transparent, repeatable and resistant to contamination. For businesses, it means testing AI systems against real operational requirements rather than purchasing products solely because they lead a public leaderboard.

Most importantly, AI progress should be judged using a combination of evidence. Accuracy matters, but so do reliability, consistency, robustness, safety, cost and the ability to solve unfamiliar problems.

A model that achieves a remarkable score on one examination may still struggle with everyday professional work. Another model with a slightly lower score may prove more dependable, economical and useful in practical situations.

The best AI system is not necessarily the one with the highest number on a leaderboard. It is the one that consistently delivers the results people need, under conditions that genuinely matter.

As artificial intelligence becomes more deeply integrated into everyday life and professional work, the quality of the measurements used to evaluate it will help determine how confidently society can adopt these technologies.

The next major AI breakthrough may not simply be a model that answers more questions correctly. It may be an evaluation system that finally tells us, with greater confidence, what these machines can actually do.

Sources and Further Reading

The following primary research publications, technical documentation and independent evaluations provide additional information about AI benchmarking, statistical measurement, contamination and real-world model performance.

  1. OpenAI — Why SWE-bench Verified No Longer Measures Frontier Coding Capabilities (February 23, 2026). Read the original audit of benchmark contamination and evaluation limitations.
  2. OpenAI — Separating Signal From Noise in Coding Evaluations (July 8, 2026). Read the investigation into SWE-bench Pro task quality and scoring problems.
  3. Scale AI — SWE-Bench Pro V2 (September 22, 2026). Explore the refreshed public benchmark and its evaluation methodology.
  4. Epoch AI — SWE-Bench Pro Benchmark Review (September 1, 2026). Read the independent assessment of the original SWE-bench Pro evaluation.
  5. Stanford Center for Research on Foundation Models — Holistic Evaluation of Language Models (2022). Explore the original HELM framework and its approach to comprehensive model evaluation.
  6. Liang et al. — Holistic Evaluation of Language Models (2023). Read the published research on standardized and multidimensional language model evaluation.
  7. OpenAI — Measuring the Performance of Our Models on Real-World Tasks: GDPval (September 25, 2025). Explore the professional task evaluation and its human-grading methodology.
  8. METR — Task-Completion Time Horizons of Frontier AI Models (Updated September 8, 2026). Explore the research methodology for measuring AI task duration and reliability.
  9. Badertdinov et al. — SWE-rebench: An Automated Pipeline for Task Collection and Decontaminated Evaluation of Software Engineering Agents (NeurIPS 2025). Read the research on continuously collected software engineering tasks.
  10. Yang et al. — Rethinking Benchmark and Contamination for Language Models with Rephrased Samples (2023). Read the research on paraphrasing and benchmark contamination detection.
  11. National Institute of Standards and Technology — Artificial Intelligence Risk Management Framework: Generative Artificial Intelligence Profile, NIST AI 600-1 (July 26, 2024). Read the official guidance on generative AI evaluation and risk management.
  12. Stanford Center for Research on Foundation Models — HELM GitHub Repository. Explore the open-source evaluation framework, documentation and maintenance information.

Editorial note: Benchmark scores and reported results are specific to the datasets, model versions and evaluation procedures used in each study. Findings from an individual organization or research team should be interpreted in light of their methodology, independent validation and stated limitations. The SWE-bench Pro V2 release represents a revised benchmark version and should be distinguished from earlier audits of SWE-bench Pro. This article discusses research and measurement principles rather than endorsing a particular AI provider.

Describes how much better the best closed-sources large language models are in 2023, compared to open-weight models, on a few key benchmarks. Closed-source still has a significant lead.
Describes how much better the best closed-sources large language models are in 2023, compared to open-weight models, on a few key benchmarks. Closed-source still has a significant lead. — Stanford Institute for Human-Centered Artificial Intelligence (permission obtained by email from the AI index research manager), CC BY-SA 4.0. Unmodified image.
AI performance on compared to humans, on the benchmarks ImageNet Top-5, SQuAD 1.1, SuperGLUE, VQA, MMLU, and MATH. Shows that AI matched or surpassed human level on several image or language understan
AI performance on compared to humans, on the benchmarks ImageNet Top-5, SQuAD 1.1, SuperGLUE, VQA, MMLU, and MATH. Shows that AI matched or surpassed human level on several image or language understanding benchmarks. Because of this, researchers have to design new and harder benchmarks (in coding, reasoning, agency...). — Stanford Institute for Human-Centered Artificial Intelligence (permission obtained by email from the AI index research manager), CC BY-SA 4.0. Unmodified image.
Share this perspectiveFacebook ↗

The conversation

Post a Comment