AI Benchmarks Explained

The variety of different AI models is increasing every day. It feels like every week there's a new model drop from OpenAI, Google, Anthropic, or some company you've barely heard of. With so many options out there, how can you actually know which ones are the best? The answer: benchmarks. But what is a benchmark, how do they work, and how much should you trust them? For the answers to those questions and more, keep reading.

A benchmark is a way to test an AI model's capabilities in a certain field. Think of it like a standardized test, but for AI. Some benchmarks test programming ability, others test a model's knowledge in specific scientific fields, and others test reasoning or math. There are benchmarks for just about everything you could want an AI to do.

For example, TerminalBench 2.1 tests how well an AI can run terminal commands. GPQA is a multiple choice benchmark that tests graduate level biology, chemistry, and physics knowledge. AIME tests mathematical problem solving. HumanEval tests code generation. The list goes on and on, and it keeps growing.

Usually, benchmarks are measured in percent of questions answered correctly. So if a model scores 85% on GPQA, that means it got 85% of the questions right. Simple enough. When a new model launches, the company behind it will almost always publish a table of benchmark scores showing how their model stacks up against the competition. These numbers are what headlines are made of, and they're often what people use to decide which model is the best.

But these numbers don't always tell the full story.

Before we get into why scores mislead, it helps to know what the big ones actually are, because they are not equally trustworthy:

- GPQA (Diamond): Graduate-Level Google-Proof Q&A. The Diamond subset is 448 expert-written science questions designed so that even PhDs with web access struggle — human domain experts score just 65–74% on them. It is one of the few academic benchmarks that still separates frontier models.

- AIME: problems from the American Invitational Mathematics Examination, the olympiad-qualifying math contest. The 2025 set is 30 free-response problems with exact numerical answers — no multiple choice to luck into.

- HumanEval: 164 small Python function-writing tasks, graded automatically by unit tests (pass@1). It was the coding benchmark for years, but it is now saturated — frontier models score above 90% — and its test set leaked into training data long ago.

- MMLU / MMLU-Pro: broad knowledge across 57 academic subjects. MMLU is saturated at 92–95% for frontier models; MMLU-Pro rebuilds it with roughly 12,000 harder questions and ten answer choices instead of four, which is why you see models drop 16–33 points on it.

- SWE-bench Verified: real GitHub issues in real repositories that the model must actually resolve. The Verified set is 500 tasks validated by human annotators, and it is widely considered the gold standard for coding ability — scores on it can swing by as much as 25 points depending on the scaffolding around the model.

- Terminal-Bench: agentic terminal use — can the model complete multi-step tasks in an actual shell? Version 2.1 is 89 tasks graded by test suites, and it is one of the components of the Artificial Analysis Intelligence Index.

- Humanity's Last Exam (HLE): 2,500 questions written by domain experts with a private held-out split, explicitly designed to stay hard. Even the best models score around 50% on it.

- Composite indices: the Artificial Analysis Intelligence Index aggregates nine independently-run evaluations into a single 0–100 score, weighted equally across four categories: agents, coding, general capability, and scientific reasoning. LMArena (the old Chatbot Arena) goes the other direction — millions of pairwise human votes converted into Elo ratings. Human preference is the most realistic signal available, though it is known to reward longer, better-formatted answers, which is why style-controlled variants exist.

This type of benchmark, where a model answers a fixed set of questions and gets a score, isn't always as accurate as it looks. There are a few reasons for this:

1. The benchmarks don't always test what the user actually does. This is probably the most common issue. A benchmark might test an AI's capability in frontier level math, the kind of stuff that would challenge a PhD student, and give it a very high score. Great, right? But then you ask for it to do a high school level math problem, and it confidently makes up an answer. The benchmark score looked impressive, but it didn't reflect how the model actually performs on the tasks real people need it for.

2. Data Contamination. AI models are trained on massive datasets scraped from the internet. If the questions from a benchmark are floating around online, there's a real chance the model has seen them during training. That means the model isn't actually solving the problem, it's just recalling the answer. By 2026 this isn't an edge case — it's the default assumption. Benchmark splits leak into web crawls, GitHub mirrors, forum posts, and synthetic training pipelines, which is how a model can report 98% on grade-school math (GSM8K) without generalizing the math underneath.

3. Goodhart's Law. 'When a measure becomes a target, it ceases to be a good measure.' When AI companies optimize their training specifically to pass popular benchmarks like MMLU or HumanEval, the benchmark loses its ability to measure true general intelligence.

There's a quieter problem behind all of this: saturation. When every frontier model scores above 90% on a test, the test stops sorting them. MMLU sits at 92–95% at the top, GSM8K at 98%+, HumanEval above 93%, HellaSwag above 97%. Headline scores that close together are statistical ties dressed up as rankings.

The field's response is a treadmill of replacements: GPQA Diamond and Humanity's Last Exam step in where MMLU stopped differentiating; AIME and FrontierMath replace grade-school math; SWE-bench Verified and LiveCodeBench replace HumanEval for coding; RULER replaces the old needle-in-a-haystack long-context tests. The replacements share a design philosophy — be fresh, be private, or be too hard to memorize. LiveBench publishes brand-new problems every month, LiveCodeBench only counts contest problems submitted after a model's training cutoff, and the hardest suites keep their evaluation sets private or unpublished entirely.

So when you see a launch headline bragging about a benchmark score, the first question to ask is whether that benchmark still means anything. A 94% on MMLU in 2026 is table stakes; a 35% on HLE is news.

Here's the checklist I use before trusting any score, including the ones in our own model reviews:

1. Check who ran the numbers. Vendor-reported scores and independently-run scores are different currencies. Artificial Analysis runs every component of its index itself precisely so leaderboard positions can't be gamed by launch-day marketing charts — and independent evaluation of new releases routinely lands lower than the announcements.

2. Match the category to your workload. A model can win olympiad math and still write mediocre CSS. Look at the per-category scores — coding, agentic, math, knowledge — and weight the ones that resemble what you actually do.

3. Ask what harness was used. Agentic benchmarks in particular are extremely sensitive to scaffolding: the same model can swing 25 points on SWE-bench depending on the agent framework around it. A benchmark score for a model inside a polished harness is not a promise about the model alone.

4. Prefer fresh and private evaluations. LiveBench, LiveCodeBench, HLE, and ARC-AGI 2 exist because their authors understood contamination. An old public benchmark with a leaked test set tells you almost nothing in 2026.

5. Read the cost and speed columns too. Intelligence per dollar is usually the real contest. A model that scores 3 points lower at a quarter of the price wins most real-world decisions, which is exactly the trade mid-tier models are built around.

6. Run your own eval. Every serious team keeps a private 'golden set' of its real tasks and runs new models against it before switching. Thirty minutes of testing on your actual workload beats every leaderboard on the internet — and if you use our workspace, the model arena makes that side-by-side comparison a couple of clicks.

The honest bottom line: benchmarks are necessary but insufficient. Treat them as a diagnostic panel, not a verdict — and remember that the moment a benchmark becomes famous enough to optimize for, that's exactly the moment you should start trusting it less.