How We Benchmark LLMs: MMLU, HumanEval, MT-Bench Explained

Published 2026-07-26 · 14 min read

Every week brings a new claim of "best AI model." But how do we actually know which model is better? Behind every benchmark leaderboard is a specific, reproducible methodology — and understanding that methodology is the difference between trusting a marketing number and making an informed decision. This guide explains the major LLM benchmarks, how they work, their limitations, and how to run them yourself.

Why Benchmarks Matter

Without benchmarks, comparing AI models is like comparing cars without a track — everyone has an opinion, but no one can prove anything. Benchmarks provide standardized tests that let us compare models on identical inputs, producing reproducible scores. For anyone choosing an LLM for production, benchmarks are the starting point for decision-making.

But benchmarks are not perfect. A model that scores 95% on a benchmark might still produce terrible results on your specific use case. The key is understanding what each benchmark measures — and what it doesn't.

The Big Six Benchmarks

1. MMLU (Massive Multitask Language Understanding)

MMLU is the single most cited LLM benchmark. It tests knowledge across 57 subjects — mathematics, history, computer science, law, medicine, and more — using multiple-choice questions at college and professional levels. A model that scores 90% on MMLU "knows" as much as a well-educated human across these domains.

Limitation: MMLU tests factual recall and basic reasoning via multiple choice. It doesn't test open-ended generation, creativity, or real-world task completion. A model can ace MMLU but produce rambling, unhelpful responses.

2. HumanEval (Code Generation)

HumanEval measures functional code generation. Each problem provides a function signature and docstring, and the model must write code that passes unit tests. It's the standard benchmark for "can this model actually code?"

Each problem is scored as pass@1 (one attempt) or pass@10 (best of 10 attempts). Production coding assistants care about pass@1 — users don't want to regenerate code 10 times.

Limitation: HumanEval has only 164 problems — too few to capture real-world coding diversity. It also tests isolated functions, not full applications. A model that aces HumanEval might struggle with multi-file refactoring or debugging.

3. MT-Bench (Multi-Turn Conversation)

MT-Bench evaluates multi-turn conversation quality using GPT-5 as a judge. It presents a model with a sequence of questions, then scores the responses on helpfulness, relevance, depth, and fluency. This is closer to real chatbot usage than single-turn benchmarks.

Limitation: Using an AI as a judge introduces its own biases. GPT-5-judged benchmarks tend to favor GPT-5-family models. Cross-model judging remains an active research problem.

4. GSM8K (Grade School Math)

GSM8K contains 8,500 grade-school-level math word problems. Despite the name, it's surprisingly challenging for LLMs because it requires multi-step reasoning, not just computation. A model needs to break down "If John has 3 apples and gives half to Mary..." into discrete steps and execute them correctly.

DeepSeek R1's lead here is notable — its specialized reasoning training makes it particularly strong on math. See our DeepSeek R1 tutorial for practical applications.

5. GPQA (Graduate-Level Questions)

GPQA (Google-Proof Q&A) tests whether models can answer PhD-level questions in biology, physics, and chemistry. These questions are designed so that even with internet access, a non-expert human would struggle. GPQA separates genuine deep knowledge from surface-level pattern matching.

6. MMMU (Massive Multi-discipline Multimodal)

MMMU tests multimodal understanding — can the model reason about images, charts, and diagrams alongside text? This is increasingly important as applications move beyond pure text into document analysis, visual Q&A, and multimodal agents.

How to Run Benchmarks Yourself

Don't just trust published numbers — run them yourself. Here's how using the popular lm-evaluation-harness framework:

# Install the evaluation harness
pip install lm-eval

# Run MMLU on GPT-5 via DrAI API
lm_eval --model openai \
  --model_args model=gpt-5,base_url=https://ai.dr-ai.top/v1,api_key=sk-your-key \
  --tasks mmlu \
  --num_fewshot 5 \
  --batch_size 20

# Run HumanEval
lm_eval --model openai \
  --model_args model=gpt-5,base_url=https://ai.dr-ai.top/v1,api_key=sk-your-key \
  --tasks humaneval \
  --num_fewshot 0 \
  --batch_size 10

Running benchmarks yourself ensures you're comparing models on your own terms, with your own API provider, using the latest benchmark versions.

The Problem with Benchmark Gaming

Benchmarks create perverse incentives. Once a benchmark becomes a marketing tool, model developers optimize for it — sometimes at the expense of real-world quality. Common gaming tactics:

Training on benchmark data: If a model has seen the test questions during training, its score is meaningless. This is called "data contamination" and is notoriously hard to detect. Researchers estimate 15-30% of popular benchmark questions appear in training data for major models.

Selective reporting: Companies publish the benchmarks where they win and omit the ones where they lose. Always look for comprehensive, third-party evaluations (like our own benchmark) rather than vendor-published numbers.

Cherry-picking prompt formats: The same model can score 85% or 92% on MMLU depending on prompt formatting (few-shot vs zero-shot, chain-of-thought vs direct answer). Companies report the format that gives the highest number.

Beyond Standard Benchmarks: Task-Specific Evaluation

For production applications, standard benchmarks are a starting point, not a finish line. The only benchmark that truly matters is how well the model performs on YOUR tasks. Here's a framework for task-specific evaluation:

Step 1: Build an Evaluation Set

Collect 100-500 real queries from your application. Include easy, medium, and hard cases. This becomes your private benchmark — immune to data contamination.

Step 2: Define Quality Criteria

What does a "good" response look like? Define specific criteria: accuracy, tone, format, length, safety. Create a rubric that a human evaluator (or AI judge) can score consistently.

Step 3: Test Multiple Models

Run each candidate model on your evaluation set. Score the outputs using your rubric. This direct comparison on YOUR data is worth more than any public benchmark.

# Test multiple models on the same evaluation set
import requests

models = ["gpt-5", "gpt-5-mini", "claude-opus-4", "deepseek-r1"]
eval_queries = load_eval_set("eval_queries.json")

results = {}
for model in models:
    scores = []
    for query in eval_queries:
        response = call_model(model, query)
        score = score_response(response, query["rubric"])
        scores.append(score)
    results[model] = sum(scores) / len(scores)
    
for model, score in sorted(results.items(), key=lambda x: -x[1]):
    print(f"{model}: {score:.1%}")

Cost-Adjusted Benchmarking

Quality is only half the equation. A model that's 2% better but costs 10x more may be the wrong choice. We recommend tracking cost-adjusted quality — quality per dollar:

By quality-per-dollar, GPT-5-nano wins by a landslide. But remember: this only works if nano's quality is sufficient for your task. This is why task-specific evaluation matters — see our cost calculator guide and model routing strategy for practical implementations.

Emerging Benchmarks in 2026

The benchmark landscape evolves rapidly. New benchmarks filling gaps left by the classics:

SWE-bench: Tests real software engineering tasks (fixing GitHub issues). Much harder than HumanEval because it requires multi-file understanding, debugging, and testing.

AgentBench: Evaluates AI agents on multi-step tasks like web browsing, database querying, and tool use. As applications move from chat to agents, this becomes critical.

HELM (Holistic Evaluation): A meta-benchmark that runs models across dozens of tasks and provides a comprehensive fairness, bias, and toxicity assessment alongside accuracy.

Conclusion

Benchmarks are tools, not truths. They're useful for narrowing your model shortlist and tracking progress over time, but they should never be the sole basis for production decisions. The best approach: use public benchmarks to identify 3-5 candidate models, then run task-specific evaluations on your own data. Combined with cost analysis and cost optimization strategies, this gives you a data-driven foundation for choosing the right model.

Want to compare models yourself? DrAI provides API access to all major models through a single key, making side-by-side benchmarking effortless.