About LLM Benchmarks
Benchmarks are standardized tests that measure what a language model can actually do — reason, write code, solve maths, follow instructions. This page explains the benchmarks llmrun aggregates, what each one measures, and how to read the scores so you can pick the best open model you can run on your hardware.
How llmrun aggregates scores
llmrun does not run any benchmark itself. We collect published results from public, permissively-licensed sources, attribute each score to its origin, and line them up next to the VRAM and GPU requirements for every open model. Each board keeps the field's own numbers; on top of them we publish one derived index, the llmrun Composite Score, fitted across all boards so models tested on different benchmarks stay comparable — mapped to what you can run.
The categories
We group benchmarks by the skill they probe. Pick a leaderboard to see the ranked open models and which ones fit your hardware.
Reasoning
Multi-step logic and problem-solving — can the model think through a hard problem rather than recall an answer.
- GPQA Diamond — GPQA Diamond is a set of extremely hard, graduate-level science questions (physics, chemistry, biology) written by domain experts and filtered so that skilled non-experts with web access still fail. It measures genuine reasoning rather than memorization.
- ARC-AGI — ARC-AGI tests fluid, abstract reasoning on small visual grid puzzles where each task follows a novel rule the model must infer from a few examples. It deliberately resists memorization and is one of the most-watched measures of general reasoning progress.
- ARC-AGI-2 — ARC-AGI-2 is the second-generation ARC Prize puzzle set, rebuilt so that tasks solved by brute-force search or memorization were removed and every problem still requires inferring a novel rule from a handful of examples. It is markedly harder than the original ARC-AGI, and most models — open and closed alike — score near zero.
- LiveBench Reasoning — LiveBench Reasoning measures logical, multi-step reasoning using contamination-free questions that are refreshed regularly, so models cannot have trained on the test set.
- LiveBench 2026 Reasoning — LiveBench 2026 Reasoning measures logical, multi-step problem solving. It belongs to the 2026 LiveBench release (first snapshot September 2, 2026), a redesigned LiveBench in which each of seven categories is scored by a single task and questions are refreshed to limit training-set contamination. It is a different test from the original LiveBench boards, so the scores are not comparable.
- BIG-Bench Hard — BIG-Bench Hard (BBH) is the 23-task subset of BIG-Bench that earlier models found hardest — multi-step reasoning, logic, and word problems. It's a long-standing standard for tracking reasoning ability across model generations.
- SimpleBench — SimpleBench is a set of everyday, common-sense and trick questions that humans answer easily but language models often get wrong. It probes basic reasoning and robustness rather than specialist knowledge.
- CritPt — CritPt (Critical Points) tests graduate-level physics problem-solving on research-style questions spanning mechanics, electromagnetism, quantum mechanics, and more. It was created by physicists to probe whether a model can reason through multi-step physics rather than pattern-match textbook answers.
- WinoGrande — WinoGrande is a large-scale commonsense-reasoning test built around pronoun resolution: the model must pick which of two nouns a pronoun refers to in a sentence, using real-world knowledge to disambiguate. It was designed by AI2 to resist the shortcuts that let earlier models game its predecessor, Winograd.
- PIQA — PIQA (Physical Interaction QA) asks a model to choose the more sensible of two ways to accomplish an everyday physical task, testing practical, physical-world commonsense that isn't well captured by purely textual reasoning tests.
- APEX-Agents — APEX-Agents (AI Productivity Index) is Mercor's evaluation of AI agents on long-horizon, multi-application professional-services work — investment-banking, management-consulting, and corporate-law style tasks — graded against expert-produced solutions. The score is Pass@1, the fraction solved correctly on the first attempt.
- Chess Puzzles — Chess Puzzles is an Epoch AI evaluation that asks models to find the winning move in tactical chess positions drawn from real games. Because each puzzle has one verifiable correct answer and no natural-language shortcut, it isolates concrete multi-step planning.
- Mystery Game Puzzles — Mystery Game Puzzles is an Epoch AI evaluation of multi-step deductive reasoning: the model works through a mystery or logic-game scenario to arrive at the correct solution. It probes sustained, structured inference rather than single-step question answering.
- DTBench — DTBench is a set of handcrafted, expert-validated multiple-choice questions on decision theory — Newcomb-like problems and related puzzles — built by the Conceptual Reasoning Index project with Anthropic. It tests whether a model can follow an abstract argument rather than recall a fact.
- LMCA — LMCA (Language Model Conceptual Argumentation) scores models on expert-rated arguments across philosophy, decision theory, and AI risk — domains where there is no empirical feedback loop to check an answer against. It is part of the Conceptual Reasoning Index, built with Anthropic by researchers Emery Cooper and Caspar Oesterheld.
- BALROG — BALROG (Benchmarking Agentic LLM and VLM Reasoning On Games) tests long-horizon agentic reasoning across six game environments — BabyAI, Crafter, TextWorld, Baba Is AI, MiniHack and NetHack — scoring the average progress a model makes toward completing each game. It was built by UCL's DARK lab and collaborators.
- Fiction.LiveBench — Fiction.LiveBench is a long-context comprehension test: models answer questions that require tracking characters, events and relationships across a long story. llmrun shows the 16k-token score, the column Epoch AI reports as its headline.
- CL-bench — CL-bench, built by Tencent Hunyuan and Fudan University's NLP group, tests whether a model can learn new domain knowledge, rule systems and procedures purely from a long provided context — not from pretraining — and apply them correctly, across 1,899 tasks drawn from 500 scenarios. An LLM judge grades each task against dozens of fine-grained rubrics, and a task counts as solved only when every rubric passes.
- CL-bench Life — CL-bench Life, a follow-up from the CL-bench authors, tests the same context-learning skill on messier real-life material — fragmented notes, casual conversations, and behavioral logs — across 405 human-curated context-task pairs. It uses the same rubric-based LLM-judge scoring as CL-bench, requiring every rubric on a task to pass for it to count as solved.
- LiveBench 2026 Data Analysis — LiveBench 2026 Data Analysis measures questions answered by working with tables and structured data. It belongs to the 2026 LiveBench release (first snapshot September 2, 2026), a redesigned LiveBench in which each of seven categories is scored by a single task and questions are refreshed to limit training-set contamination. It is a different test from the original LiveBench boards, so the scores are not comparable.
- LiveBench 2026 Browser — LiveBench 2026 Browser measures tasks a model completes by operating a web browser. It belongs to the 2026 LiveBench release (first snapshot September 2, 2026), a redesigned LiveBench in which each of seven categories is scored by a single task and questions are refreshed to limit training-set contamination. It is a different test from the original LiveBench boards, so the scores are not comparable.
- ForecastBench — ForecastBench, from the Forecasting Research Institute, asks models to predict real-world future events, with questions that only resolve after the model's training cutoff so the answers can't have been memorised. It is scored as a difficulty-adjusted Brier index, where higher is better.
- Vending-Bench 2 — Vending-Bench 2, from Andon Labs, is a long-horizon agent benchmark in which the model runs a simulated vending-machine business for a year, handling suppliers, pricing and cash flow. The score is the final money balance in US dollars.
- Furniture Assembly — Furniture Assembly, built by Epoch AI, tests spatial reasoning with 60 photos of partly built IKEA furniture and the assembly manual: the model must say whether the build is correct so far and, if not, name the mistaken step and describe the error. Scores are accuracy across the photos, and a human baseline averaged 63%.
- EBR-bench — EBR-bench, from Epoch AI, tests whether models learn from experience by having them play the board game Earthborne Rangers over repeated playthroughs, with the rulebook, card database and a persistent note-taking tool. Scores stay roughly flat across plays and well below an expert human baseline.
Coding
Writing, editing, and fixing real code — measured by whether the resulting program actually runs and passes tests.
- LiveBench Coding — LiveBench Coding evaluates code generation and completion on fresh, contamination-free programming tasks that are updated regularly.
- LiveBench 2026 Coding — LiveBench 2026 Coding measures whether a model writes correct code for programming problems. It belongs to the 2026 LiveBench release (first snapshot September 2, 2026), a redesigned LiveBench in which each of seven categories is scored by a single task and questions are refreshed to limit training-set contamination. It is a different test from the original LiveBench boards, so the scores are not comparable.
- LMArena WebDev — Code Arena (formerly WebDev Arena) is Arena's head-to-head coding leaderboard: two models each build a real web app or UI from the same prompt, and people vote blind on which result is better. The rating shown is a relative Bradley-Terry score, not a percentage — compare it only to other models on this board.
- SWE-bench Verified — SWE-bench Verified tests whether a model can resolve real GitHub issues from popular open-source Python projects, scored on the official swebench.com leaderboard as the percentage of human-validated issues actually fixed. It is the headline measure of practical, agentic software-engineering ability — where open-weight models like Qwen3-Coder, GLM-4.6, Kimi K2 and DeepSWE are now competitive with the frontier.
- SWE-bench Bash Only — SWE-bench Bash Only runs the SWE-bench Verified issues through a minimal, single-tool bash agent — no specialised scaffolding — so the score reflects the model's own agentic coding ability rather than the harness around it. A cleaner, harder read on raw software-engineering skill.
- Terminal-Bench — Terminal-Bench measures whether a model can complete real, end-to-end tasks in a command-line environment — running commands, editing files, and chaining steps — making it an agentic test of practical software skill.
- Aider Polyglot — The Aider Polyglot benchmark measures real-world coding across several programming languages: the model edits code to solve Exercism exercises, and is scored on whether the final solution actually runs and passes the tests.
- SWE-bench Multilingual — SWE-bench Multilingual extends SWE-bench beyond Python to real GitHub issues across many programming languages, measuring whether a model can fix bugs in codebases written in Java, Go, Rust, TypeScript and more.
- SWE-bench Lite — SWE-bench Lite is a smaller, lower-cost subset of SWE-bench focused on self-contained bug fixes. It is the quickest of the SWE-bench boards to run and a common entry point for comparing coding agents.
- SciCode — SciCode asks a model to write real scientific-computing code — implementing multi-step numerical methods drawn from physics, chemistry, biology, and math research — and checks the output against reference solutions. It was built by a team of scientists and ML researchers to test coding ability on genuine research problems, not typical software tasks.
- WeirdML — WeirdML asks models to write machine-learning code for small, deliberately unusual datasets, then runs the code and scores the accuracy it actually achieves. Built by Håvard Tveit Ihle, it rewards practical problem-solving over recognizing a familiar task.
- FrontierCode — FrontierCode, from Cognition (the team behind Devin) with maintainers of open-source projects, gives an agent a real repository and issue and grades its patch on whether it's mergeable — held-out tests plus a maintainer-written rubric covering correctness, regression safety, style and project conventions. The Main set is the 100 hardest tasks.
- DeepSWE — DeepSWE, built by Datacurve, evaluates coding agents on 113 original software-engineering tasks across 91 repositories and five languages — written from scratch rather than adapted from real commits, so a model can't have seen the solution during pretraining, and graded Pass@1 with hand-written behavioral verifiers. It's a benchmark name only, unrelated to the open-weight DeepSWE-Preview coding model.
- GSO-Bench — GSO-Bench, built by a team of UC Berkeley-affiliated researchers, gives a coding agent a real codebase and a performance test and asks it to optimize runtime efficiency to match an expert developer's speedup without breaking correctness, across 102 tasks in 10 codebases and five languages. The scored metric, Opt@1, is the share of tasks where a single attempt reaches at least 95% of the human speedup while still passing all tests.
- Surface Evolver Bench — Surface Evolver Bench tests whether a model can write a correct simulation file for Surface Evolver, a physics tool that models surfaces shaped by tension, gravity and volume constraints, defining a 3D structure in its domain-specific format from only a few examples. Scores compare the resulting geometry — volume, area and energy — against reference solutions; the benchmark was built by an independent developer (GitHub: yhenon).
- FrontierSWE — FrontierSWE, from Proximal, tests coding agents on long-horizon software-engineering tasks spanning implementation, performance optimisation and open-ended research, each run for hours through an agent harness. The score is the average normalised task score across repeated runs of every task.
- LiveBench 2026 Long-Horizon — LiveBench 2026 Long-Horizon measures multi-step tasks that a model has to carry through many steps to finish. It belongs to the 2026 LiveBench release (first snapshot September 2, 2026), a redesigned LiveBench in which each of seven categories is scored by a single task and questions are refreshed to limit training-set contamination. It is a different test from the original LiveBench boards, so the scores are not comparable.
- CursorBench — CursorBench, from Cursor (Anysphere), measures agentic coding on tasks drawn from real Cursor engineering sessions rather than synthetic puzzles. Each model is run at several reasoning-effort levels, and Epoch AI reports the correctness score.
- ALE-Bench — ALE-Bench, from Sakana AI and AtCoder, tests long-horizon algorithmic optimisation using problems drawn from AtCoder Heuristic Contests, where there is no single correct answer and solutions are scored on quality. Results are reported as an AtCoder-style performance rating, where higher is better.
- ExploitBench — ExploitBench, from Carnegie Mellon University researchers Seunghyun Lee and David Brumley, scores AI agents on writing working exploits for 41 real, already-patched bugs in Chrome's V8 JavaScript engine, with modern mitigations switched on. Instead of pass/fail it grades 16 stages from crash up to arbitrary code execution, and Epoch AI reports the mean capability reached.
- METR Time Horizons — METR Time Horizons, from the AI-evaluation nonprofit METR, runs models on a suite of software-engineering and research tasks whose length is measured by how long they take skilled humans, from seconds to many hours. METR summarises each model as a time horizon: the human task length at which the model succeeds half the time. llmrun shows METR's average task-success score (0–1) as published by Epoch AI; higher means the model completes more of the suite, including longer tasks.
- LiveBench 2026 Design — LiveBench 2026 Design measures layout-design tasks (LiveBench's design_layout task). It belongs to the 2026 LiveBench release (first snapshot September 2, 2026), a redesigned LiveBench in which each of seven categories is scored by a single task and questions are refreshed to limit training-set contamination. It is a different test from the original LiveBench boards, so the scores are not comparable.
Math
Symbolic and quantitative problem-solving, from competition math to multi-step calculation.
- AIME 2024/2025 — AIME (American Invitational Mathematics Examination) is a prestigious high-school competition of hard, integer-answer problems. It's a widely-cited yardstick for multi-step mathematical reasoning, here on the 2024–2025 papers.
- MATH Level 5 — MATH Level 5 covers the hardest tier of competition-mathematics problems, testing multi-step symbolic and quantitative reasoning.
- LiveBench Math — LiveBench Math measures mathematical problem-solving on contamination-free, regularly-refreshed questions, including competition-style problems.
- FrontierMath — FrontierMath is a benchmark of exceptionally hard, original research-level mathematics problems created with professional mathematicians. Even the strongest models solve only a small fraction, making it a frontier measure of genuine mathematical ability.
- FrontierMath Tier 4 — FrontierMath Tier 4 is the hardest tier of Epoch AI's research-level mathematics benchmark, holding problems that working mathematicians consider genuinely difficult research questions. Scores here stay low even for frontier models, making it the sharpest available read on mathematical ability.
- GSM8K — GSM8K is a classic set of grade-school math word problems requiring several arithmetic reasoning steps. Long a default sanity check for reasoning, top models now score near the ceiling, so it best separates smaller models.
- ProofBench — ProofBench evaluates a model's ability to write and check rigorous mathematical proofs, rather than just produce a final numeric answer. It probes step-by-step logical correctness, which is a harder and more distinct skill than solving for a number.
Knowledge
Breadth and depth of factual knowledge across many subjects, paired with the reasoning to apply it.
- MMLU — MMLU (Massive Multitask Language Understanding) spans 57 subjects from history to law to medicine as multiple-choice questions. It is the long-standing default for broad knowledge and remains the most widely-reported general benchmark.
- Humanity's Last Exam — Humanity's Last Exam (HLE) is a set of extremely difficult, expert-written questions across many fields, designed so that even frontier models score low. It is built to stay hard as models improve, measuring the true knowledge frontier.
- SimpleQA — SimpleQA measures factual accuracy on short, fact-seeking questions with a single correct answer — directly probing how often a model is right versus confidently wrong (hallucination) on simple facts.
- LiveBench 2026 Research — LiveBench 2026 Research measures finding and combining information to answer research questions. It belongs to the 2026 LiveBench release (first snapshot September 2, 2026), a redesigned LiveBench in which each of seven categories is scored by a single task and questions are refreshed to limit training-set contamination. It is a different test from the original LiveBench boards, so the scores are not comparable.
- HellaSwag — HellaSwag is a commonsense benchmark that asks a model to pick the most plausible continuation of an everyday situation. The wrong options are adversarially chosen to fool models, testing grounded commonsense understanding.
- MMLU-Pro — MMLU-Pro is a harder, cleaned-up successor to MMLU with ten answer choices and more reasoning-heavy questions across 14 subjects, measuring broad knowledge and reasoning together.
- ARC Challenge — ARC Challenge is a set of grade-school science questions, curated by the Allen Institute for AI (AI2) to exclude ones that simple word-matching or retrieval can answer. It measures science knowledge paired with the reasoning needed to apply it.
- BoolQ — BoolQ is a reading-comprehension benchmark of naturally occurring yes/no questions, each paired with a short passage that contains the answer. It tests whether a model can extract and reason over information from real text rather than just recall facts.
- OpenBookQA — OpenBookQA is a science-question benchmark modeled on open-book exams: the model is given a small set of core science facts and must combine them with broader common knowledge to answer multi-step questions. It targets reasoning over recall.
- TriviaQA — TriviaQA is a large set of trivia questions paired with evidence documents, testing a model's factual recall and reading comprehension across a wide range of everyday topics.
Instruction Following
How precisely a model obeys explicit, verifiable instructions — format, length, and content constraints — and, more broadly, how much people prefer its responses head-to-head in blind human voting.
- LMArena Text — Arena (arena.ai, formerly LMArena / Chatbot Arena) ranks models by millions of blind, head-to-head human votes on real prompts. The Arena Score shown here is a Bradley-Terry rating computed with Arena's default style control, so higher means people preferred that model's answers more often — it's a relative rating, not a percentage, so compare it only to other models on this board.
Reading the scores
Most scores are an accuracy or pass-rate (a percentage of items answered correctly); suites like LiveBench use a normalized 0–100 score. Higher is always better here. Each benchmark has its own scale and difficulty, so compare models within a single leaderboard rather than across different ones. On every leaderboard, the score-vs-size chart highlights models that punch above their weight — high quality at a small size is what makes a model worth running locally.
Open vs proprietary models
Open models have downloadable weights — those are llmrun's focus, and each links to its VRAM and GPU requirements. Proprietary models (GPT, Gemini, Claude and friends) are shown dimmed behind the All models toggle on each leaderboard, so you can see where the open field stands against the closed frontier without pretending you can run them at home.
FAQ
- Does llmrun run these benchmarks itself?
- No. llmrun is an aggregator — it collects published scores from public sources (Epoch AI, LiveBench, Aider, LMArena and others), attributes each to its origin, and presents them in one place alongside the hardware you'd need to run each open model. We never re-run a benchmark or invent a composite score.
- What does a benchmark score actually mean?
- Most scores are an accuracy or pass-rate: the fraction of test items the model got right (shown as a percentage), or a normalized 0–100 score for suites like LiveBench. Higher is better. Because each benchmark uses its own scale and methodology, compare models within a single benchmark rather than across different ones.
- How is the llmrun Composite Score on a model's page calculated?
- It is the llmrun Composite Score: an open-ended capability index (100 is the average model of the reference field, with no upper limit) fitted across the benchmarks current models are still submitted to with Item Response Theory, so a hard benchmark counts as hard instead of being averaged away. Every score comes with a 90% range, and a model needs results on at least 4 qualifying benchmarks across 2 categories (including reasoning or coding), or on 3 that pin its score down to a 90% range of at most 15.6 points, before we publish it — and the results must come from at least two different benchmarks, not just categories of one. Saturated classics like MMLU and HellaSwag keep their own leaderboards but do not feed the score, and Arena (LMArena) ratings are shown as their own leaderboards only. See the methodology page for the full method.
- Why do some leaderboards show fewer models than others?
- We only list a model on a benchmark when a trustworthy public score exists for it. Newer or niche open models may not have been evaluated on every benchmark yet, so coverage varies by leaderboard.
- What's the difference between open and proprietary models here?
- Open models have downloadable weights you can run on your own hardware — those are llmrun's focus, and each links to a page with VRAM and GPU requirements. Proprietary (closed) models are shown dimmed behind the 'All models' toggle for context: you can see where the open field stands relative to the frontier, even though you can't run them locally.
- How fresh are the scores?
- Each leaderboard shows when its data was last refreshed. Several sources (LiveBench, Aider) update on a rolling basis with contamination-free questions, and we re-import periodically.