Every benchmark defines a measurement

A benchmark combines tasks, an execution protocol, a scoring rule, and an aggregation method. Change any of those and the meaning of the score changes. Before comparing numbers, check the dataset version, prompt format, number of samples, tools, scaffold, compute budget, and pass criteria.

A high score can support a narrow claim about performance under that protocol. It cannot establish universal intelligence, production reliability, or fitness for a workflow the benchmark did not represent.

The benchmark dataset is also a sample, not the capability itself. Confidence depends on task quality, coverage, scoring validity, and whether the evaluated system had prior exposure to the tasks or solutions. These properties can change while the benchmark name stays the same.

Four benchmarks, four different questions

MMLU measures multiple-choice accuracy across 57 subjects. HumanEval measures functional correctness for 164 handwritten Python problems. SWE-bench measures whether a system can modify repositories to resolve real issues. AgentBench measures task completion across eight interactive environments. Their units of work range from one answer to an extended model-tool trajectory.

Capability claims expand with task scope

Moving from a single answer to an interactive repository task introduces more of the system, which makes the result more product-relevant but also harder to attribute to one component.

  1. Answer level

    Multiple-choice response

    Measures the selected answer under a fixed prompt and option set. Model output is the main moving part.

  2. Program level

    Standalone function

    Adds code generation, sampling policy, executable tests, and sandbox behavior.

  3. Repository level

    Issue resolution

    Adds codebase navigation, editing, test selection, environment setup, and regression control.

  4. Agent level

    Interactive environment

    Adds long-horizon decisions, tool selection, observation, recovery, permissions, and stopping behavior.

  5. Product level

    Real user workflow

    Adds actual task distribution, latency, cost, review effort, organizational policy, and consequences of failure.

The benchmark examples correspond to the evaluation units used by MMLU, HumanEval, SWE-bench, and AgentBench.

What prominent benchmarks are designed to measure
BenchmarkUnit of evaluationPrimary signalImportant limitation
MMLUMultiple-choice item in 57 subjectsAccuracyKnowledge and reasoning in a fixed exam format
HumanEval164 standalone Python problemsFunctional pass@kSmall function synthesis, not repository work
SWE-bench2,294 issues from 12 Python repositoriesIssue resolution through testsOutcome depends on environment and agent scaffold
AgentBenchTasks in 8 interactive environmentsEnvironment-specific successBroad suite with heterogeneous tasks and protocols

Curation can change what the score means

The original SWE-bench collected 2,294 instances from issues and pull requests across 12 Python repositories. OpenAI and the benchmark authors later created SWE-bench Verified, a human-reviewed subset of 500 instances, after finding examples with underspecified issue text, overly specific tests, and environment problems.

The Verified work also highlights a system-level fact: the same model can produce different results under different agent scaffolds. Repository browsing, tool interfaces, context construction, editing strategy, and retry policy are part of the evaluated system.

The SWE-bench project now publishes a bash-only comparison that holds the mini-SWE-agent environment more constant across models. Its documentation still warns that results from major scaffold releases are not necessarily comparable. Standardizing more of the system improves attribution, but it does not remove dataset limitations.

Source figure

SWE-bench turns repository history into an executable task

SWE-bench flow from a GitHub issue and repository snapshot to a generated patch evaluated by fail-to-pass and regression tests

Figure 1 from the SWE-bench paper connects an issue to a repository snapshot and evaluates a generated patch against tests derived from the merged pull request. The diagram makes the benchmark's unit of work explicit.

Jimenez et al., Figure 1

Scoring rules encode product assumptions

Accuracy counts one selected answer. Pass@k estimates whether at least one of k samples is correct. Repository resolution requires all designated tests to pass. Agent environments define their own success conditions. Each metric rewards a different operating procedure.

A metric can reject a useful result when the reference is too narrow, or accept an incomplete result when tests have low coverage. Human review can catch some of these problems, but reviewers also need a rubric, representative expertise, and disagreement handling.

Report uncertainty around the measurement. Repeated sampling, task subsampling, grader variation, and environment instability can change results. A small score difference is not automatically meaningful if it is smaller than normal run-to-run or review variation.

Published benchmark values and later data-quality audits. Each row has its own denominator and should be read independently.
Source and populationMeasured valueDenominatorInterpretation
Original SWE-bench evaluation1.96% resolved by the best reported baseline2,294 repository issuesHistorical 2023 paper result under its original setup
SWE-bench Verified audit59.4% had material issues138 frequently failed tasks reviewedAudit subset, not the full 500-task set
SWE-Bench Pro automated pipeline27.4% flagged broken200 of 731 public tasksAgent-assisted data-quality pipeline
SWE-Bench Pro human review34.1% identified as broken249 of 731 public tasksFive experienced engineers reviewed each flagged task

Public benchmarks can leak into training

A public benchmark is reproducible because its tasks and often its solutions are available. That same openness creates contamination risk when training corpora include benchmark pages, repositories, discussions, or solution artifacts. Performance may then reflect prior exposure as well as general problem-solving ability.

In a 2026 analysis, OpenAI reported evidence that frontier models could reproduce details from SWE-bench Verified problems or gold patches and stopped using that benchmark to measure frontier coding progress. The conclusion is specific to that measurement regime, but the evaluation principle is general: track exposure risk and refresh tasks when the signal degrades.

Private or newly created holdout tasks reduce direct exposure, but they still require quality review. The strongest program combines controlled holdouts with transparent public benchmarks, real product tasks, and detailed failure analysis rather than relying on one secret number.

Build product evaluations beside public benchmarks

Start with real tasks sampled from the product's intended use. Freeze the input state, define acceptable outcomes and prohibited changes, and run the same task across candidate systems. Keep a held-out set for release decisions and a diagnostic set for rapid iteration.

For coding agents, combine automated checks with human review. Tests can establish behavior on covered cases; reviewers can judge scope control, maintainability, explanation quality, and whether the agent made unsafe or unnecessary changes.

  • Task success and regression rate.
  • Unnecessary tool calls, edits, and permission requests.
  • Recovery after a failed test or unavailable tool.
  • Human review time and severity of required corrections.
  • Latency and cost to a verified result.

Treat evaluation as maintained infrastructure

Static public benchmarks can become less discriminating as models and training corpora evolve. Product tasks also drift when users, tools, and policies change. Version datasets, record failures, add new cases from incidents, and preserve old cases that protect important behavior.

Publish disaggregated results. An average can hide a critical regression in one task family or user group. A useful evaluation report says what was tested, where the system improved, where it failed, and what remains outside the scope of the evidence.

A July 2026 audit of SWE-Bench Pro estimated that roughly 30 percent of its public tasks were broken, with problems including strict tests, underspecified prompts, low-coverage tests, and misleading instructions. The authors retracted an earlier recommendation to use that benchmark. This is a useful example of evaluation governance working: inspect the data, publish the failure, and change the claim.

Sources and further reading

Claims and figures in this article were checked against these original papers and official project resources.

  1. 1
    Holistic Evaluation of Language Models

    Stanford Center for Research on Foundation Models, 2022

  2. 2
    Measuring Massive Multitask Language Understanding

    International Conference on Learning Representations, 2021

  3. 3
  4. 4
    SWE-bench: Can Language Models Resolve Real-World GitHub Issues?

    International Conference on Learning Representations, 2024

  5. 5
  6. 6
    SWE-bench Verified

    SWE-bench, 2026

  7. 7
  8. 8
  9. 9
    AgentBench: Evaluating LLMs as Agents

    International Conference on Learning Representations, 2024