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.
Answer level
Multiple-choice response
Measures the selected answer under a fixed prompt and option set. Model output is the main moving part.
Program level
Standalone function
Adds code generation, sampling policy, executable tests, and sandbox behavior.
Repository level
Issue resolution
Adds codebase navigation, editing, test selection, environment setup, and regression control.
Agent level
Interactive environment
Adds long-horizon decisions, tool selection, observation, recovery, permissions, and stopping behavior.
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.
| Benchmark | Unit of evaluation | Primary signal | Important limitation |
|---|---|---|---|
| MMLU | Multiple-choice item in 57 subjects | Accuracy | Knowledge and reasoning in a fixed exam format |
| HumanEval | 164 standalone Python problems | Functional pass@k | Small function synthesis, not repository work |
| SWE-bench | 2,294 issues from 12 Python repositories | Issue resolution through tests | Outcome depends on environment and agent scaffold |
| AgentBench | Tasks in 8 interactive environments | Environment-specific success | Broad 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
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 1Scoring 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.
| Source and population | Measured value | Denominator | Interpretation |
|---|---|---|---|
| Original SWE-bench evaluation | 1.96% resolved by the best reported baseline | 2,294 repository issues | Historical 2023 paper result under its original setup |
| SWE-bench Verified audit | 59.4% had material issues | 138 frequently failed tasks reviewed | Audit subset, not the full 500-task set |
| SWE-Bench Pro automated pipeline | 27.4% flagged broken | 200 of 731 public tasks | Agent-assisted data-quality pipeline |
| SWE-Bench Pro human review | 34.1% identified as broken | 249 of 731 public tasks | Five 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.
- 1Holistic Evaluation of Language Models
Stanford Center for Research on Foundation Models, 2022
- 2Measuring Massive Multitask Language Understanding
International Conference on Learning Representations, 2021
- 3Evaluating Large Language Models Trained on Code
OpenAI, 2021
- 4SWE-bench: Can Language Models Resolve Real-World GitHub Issues?
International Conference on Learning Representations, 2024
- 5Introducing SWE-bench Verified
OpenAI, 2024
- 6SWE-bench Verified
SWE-bench, 2026
- 7
- 8
- 9AgentBench: Evaluating LLMs as Agents
International Conference on Learning Representations, 2024