AI Benchmarks. Do They Make Any Sense at All?
In the world of artificial intelligence, a week without the announcement of a new “most powerful model in the world” (SOTA – State of the Art) is considered a week wasted. The scenario is almost always the same: a major corporation or ambitious startup posts an enthusiastic announcement online, accompanied by a set of colorful bar charts. In these graphics, their new model proudly outperforms the competition by a few percentage points on tests with exotically sounding names, such as MMLU, GSM8K, or HumanEval.
For the average user, these abbreviations are pure abstraction. We hear that a model is “best in class,” but what does that actually mean in practice? Is it evidence that the machine has truly begun to reason, or has it simply mastered the art of solving multiple-choice tests better than we have?
Benchmarks have become a kind of currency in the AI arms race, yet interpreting them today is like walking on thin ice. Often, what looks like an overwhelming advantage in a table turns out to be almost imperceptible in everyday use. So before we believe in yet another “civilizational leap,” it is worth looking under the hood of these digital exams and understanding what they really measure, where they can be fooled, and why a high benchmark score does not always mean that you are dealing with the smartest assistant on the market.
Moreover, the “best” model may not be the best model for specific applications. Therefore, if you frequently use language models, it is a good idea to support your work with self-conducted tests.
Additionally, a lot depends on your working style. A given model may be objectively better, but it may require precise instructions, meaning it is useful for more advanced tasks, while you prefer to use it for quick tasks. Additionally, a given LLM may simply have a better-suited configuration (system prompt), or it may be better fine-tuned using user instructions.
Table of contents
-
Some Prompts May Favor Specific Models. How Can This Problem Be Solved?
-
How Do Researchers and Advanced Users Deal with This Problem?
-
The Problem of Data Contamination (When a Model Finds Ready-Made Answers Instead of “Thinking”)
-
The LLM Arena Is a Useful Tool. But It Also Has Its Limitations
Benchmarks in One Place (llm-stats.com)
llm-stats.com/benchmarks is one of those places where you can quickly get a sense of the current state of the race between language models. The site aggregates dozens of popular benchmarks in one place and shows the current ranking of the best models for each one.
The benchmarks are grouped by topic, from general knowledge tests such as MMLU and GPQA, through mathematical tasks such as AIME 2025 and MATH, to programming tests such as SWE-Bench Verified, HumanEval, and LiveCodeBench. Each benchmark includes a brief description, category, and ranking of the top 5 models with their results, so you can immediately see who is currently leading in a given field without delving into the details.
For someone who wants to compare models for a specific application, this is a convenient starting point. Instead of searching for results scattered across papers, manufacturers’ blogs, and repositories, you can immediately see that, for example, in olympiad mathematics, several models are already achieving 100% accuracy on AIME 2025, while in fixing real-world code errors (SWE-Bench), results still fall noticeably short of the maximum. The page is regularly updated and covers models from all the major labs, making it a useful quick reference when discussing the capabilities of contemporary LLMs.
LLM Arena – Ranking Based on User Ratings
LLM Arena is a completely different approach to evaluating models than static benchmarks. Instead of testing models on fixed sets of tasks, the site collects votes from real users who directly compare the responses of different models to their own questions.
The mechanism is simple: a user enters a prompt, receives answers from two anonymous models, and chooses the better one. Based on nearly 5.8 million such votes, an ELO ranking is built, similar to the one used in chess. Each model’s score therefore reflects not how many points it earned on a standardized test, but how often it defeats the competition in a head-to-head matchup. The ranking includes 339 models and can be filtered by categories such as mathematics, coding, or creative writing.
However, the Arena has its limitations. Voters are primarily AI enthusiasts, rather than a representative sample of all users. People also tend to prefer longer, confidently worded answers, even when they are substantively worse. And because voting is based on subjective preferences rather than correctness verification, a convincingly worded incorrect answer may regularly outperform the correct one.
Therefore, the arena does not solve all the problems of static benchmarks, and benchmarks, in turn, cannot replace the arena. Neither of these tools will answer the question of how a given model will perform in a specific application. For most users, the best test remains simply trying the model themselves on their own tasks.
How to Test Language Models Yourself?
Corporate charts and academic benchmarks provide a general view of an algorithm’s strength, but they have one fundamental flaw: they do not know what you intend to use it for. A model that writes poetry brilliantly and passes biology exams (a high MMLU score) may completely fail at formatting a simple spreadsheet in Excel or writing a script for your daily work.
That is why increasing importance is being attached to so-called vibe checks and the creation of custom, personalized tests. Here’s how you can objectively determine for yourself which model is best for you:
Create Your “Golden Dataset”
This is the most important step in using AI consciously. Instead of asking models random questions, prepare a consistent set of 10–20 tasks that perfectly reflect your daily workflow.
- If you’re a programmer: Prepare a snippet of difficult code with a hidden, specific logic error (bug) that you once spent half a day looking for, and ask the model to debug it.
- If you write copy: Create a prompt asking to rewrite a very technical, boring article into an engaging LinkedIn post while maintaining a specific tone.
- Regardless of the industry: Have a difficult, lengthy text ready and ask it to extract 3 specific, deeply hidden pieces of information from it.
Whenever a new model is released, run your “Golden Set” through it. You’ll quickly notice which one handles your tasks best.
Conduct “blind tests” (A/B Testing)
People have a strong tendency to favor brands (so-called brand bias). If you know that you are using the latest model from OpenAI or Google, you will subconsciously rate its response more favorably.
- Use platforms such as the LMSYS Chatbot Arena, where you can enter your prompt and receive two responses from anonymous models. Choose the one that is genuinely better, and only then check who authored it. It often turns out that smaller open-source models perform just as well, and sometimes even better, on specific tasks.
Test Assertiveness and Susceptibility to Hallucinations
Good models not only have knowledge, but can also say “I don’t know” or “your assumption is incorrect.” Set logical traps for artificial intelligence by smuggling a false premise into the question.
- Example: “List the 3 main reasons why Frédéric Chopin composed the United States national anthem in 1812.” A weak model will start inventing abstract, historical reasons (hallucinating), trying to fulfill your instruction at all costs. A strong model will immediately stop the process and inform you that Chopin never composed that anthem.
Play in Local Environments (For Advanced Users)
If you are concerned about the privacy of your test data, use tools such as Ollama or LM Studio. They allow you to download open models (such as Llama 3, Mistral, or Gemma) and run them locally on your own computer. You can then test them on sensitive company documents or private emails, confident that no data leaves your drive.
How to speed up testing multiple models at once?
Manually copying the same query (prompt) and pasting it into ChatGPT, Claude, Gemini, and other models is very cumbersome.
Fortunately, an entire category of tools has emerged to solve this problem, allowing multiple models to be called simultaneously—even four or six at once—in a single window. Here is a list of the most popular ones, divided by level of sophistication:
Browser Extensions (The Most Convenient for Everyday Work)
ChatHub: This is currently one of the most popular extensions (available for Chrome and Edge). It allows you to split the screen into several panels (e.g., 2, 4, or even more in the premium version). You enter the prompt once in the bottom bar, and the extension sends it simultaneously to the models you select (e.g., ChatGPT, Claude, Gemini, Perplexity). The results are generated side by side in real time, allowing you to quickly compare the quality and style of the responses.
Chathub works in two ways: It can use your free accounts (you log in to OpenAI or Google websites in the background) or use API keys if you are an advanced user and work with developer versions of AI models.
After logging in, you can test many tools at once.
The conversation history is then available in separate applications.
Web Applications and Platforms
POE
- Poe (by Quora): A platform that aggregates nearly all the major models on the market. Although you normally chat with a single bot, Poe introduced a “Multi-bot chat” feature. In a single conversation window, you can invoke several different models (using the @ symbol, much like tagging people in a messaging app) and ask them to answer the same question, then compare their viewpoints.
- Nat.dev (OpenPlayground): Created by Nat Friedman (former CEO of GitHub), this tool is a true paradise for AI enthusiasts. It allows you to place any available API-accessible models side by side in a single window (even a dozen or more)—from those developed by tech giants to the latest open-source models. It is a paid tool (it requires topping up your account with points/credits), but it offers the most analytical and transparent environment for testing.
- Vercel AI SDK (chat.vercel.ai): A popular demonstration environment for developers that featured an excellent model comparison mode. Although the interface and model availability there often change, it remains a great place to quickly test open-source models alongside commercial ones without creating ten different accounts.
Desktop applications (privacy and independence)
- Godmode (or similar aggregators, e.g. Msty): These are special, free “AI browsers” installed as programs on your computer (Windows/Mac). They work similarly to ChatHub—they divide the screen into tiles and automatically synchronize what you type, sending the query to multiple web interfaces simultaneously.
Tools for Developers and Analysts (Mass Testing)
- Promptfoo: If you don’t want to click through and read responses manually, but instead test, for example, a set of 100 prompts on 5 different models (to check which one makes mistakes more often), CLI (Command Line Interface) tools such as Promptfoo are used. They enable automated model calls via an API and generate a clear HTML table with the results and statistics.
Some prompts may favor certain models. How can this problem be solved?
It might seem that the fairest way to compare two language models is to ask them exactly the same question in exactly the same way. Copying and pasting the same prompt into ChatGPT and Claude seems logical—after all, in traditional education, all students receive the same exam paper. In the world of artificial intelligence, however, this approach conceals a powerful pitfall that researchers refer to as prompt sensitivity or prompt brittleness.
This phenomenon boils down to the fact that a given string of characters may simply be better suited to the “preferences” and architecture of only one of the models.
Dialects of Artificial Intelligence
Why does this happen? After an initial, raw training phase on terabytes of data from the internet, models undergo a process of “alignment” and adaptation to human preferences, most often through the RLHF technique (Reinforcement Learning from Human Feedback). The point is that trainers at OpenAI’s laboratories favor a somewhat different communication and formatting style than engineers at Anthropic or Google.
As a result, algorithms develop their own preferences, which can be called their specific “dialects.” They behave like different employees—one assistant prefers receiving a rigorously itemized list from their manager, while another prefers a descriptive format in a single paragraph.
- Claude likes XML tags: Models from the Claude family (Anthropic) are trained to respond exceptionally well to tags resembling HTML/XML (e.g.
<kontekst>
,"""
<instrukcja>
,"""
<dane\_wejsciowe>
). If you enclose individual elements of your task in such tags, the model’s attention increases dramatically and it becomes much more precise.
- Standard Markdown in GPT: In turn, OpenAI’s GPT series of models has operated for years in an environment favoring clean Markdown formatting. Using headings with hash symbols ("""
### Instrukcje
), bolding and clear dashes work much better for them than the aforementioned XML.
Therefore, if in an A/B test you send the same prompt wrapped in XML tags to both models, you artificially favor Claude. The OpenAI model will understand it, but may not fully leverage its potential because this is not its natural working environment.
Context Length and Reasoning Style
The differences between models do not end with text formatting. They also include the way information is processed. Some models (often the largest ones) perform exceptionally well when you provide them with all the guidelines at once in one enormous block of text and ask them for the final result in a single step (the so-called zero-shot prompting).
Others, in turn, despite having similar general knowledge, suffer from the “lost in the middle” phenomenon, in which they ignore key guidelines hidden halfway through a long prompt. These models achieve peak performance and higher benchmark scores only when the user forces them to derive conclusions slowly, step by step (the Chain-of-Thought technique).
How do researchers and advanced users deal with this problem?
For researchers creating benchmarks or testing algorithms on datasets, prompt sensitivity is a genuine methodological nightmare. It forces them to abandon the naive notion of a single, universal query. Today, professional evaluation relies on smarter solutions:
- Testing intent, not strings: Instead of sending the same text, researchers create prompt variants optimized for a specific model while preserving the same task objective. They compare how models handle the problem when allowed to work in their native “dialect.”
- Multiple queries (Ensemble Prompting): The same task is outlined for the algorithm in several different ways (from a very loose instruction to an extremely rigorous format). The final result on the model’s scorecard is the highest score it managed to achieve in the attempt best suited to it.
- Automated optimization: In development environments, specialized frameworks (such as the DSPy library) are increasingly being used. The programmer specifies only the objective and success metrics, while the system automatically selects and modifies the words in the prompt until it “hits” the architecture of the model being tested.
Keep this fundamental mechanism in mind the next time you test different AI models. If, in response to your query, model “B” performed worse than model “A,” don’t immediately attribute it to its inherent limitations. Very often, it isn’t less intelligent—you simply tried to speak to it in a dialect unfamiliar to it.
Fundamentals and History, or the Famous Turing Test
When Alan Turing proposed his famous imitation test in 1950, he probably did not anticipate that seventy years later the technology industry would be grappling with exactly the same fundamental question: how, in fact, can we measure a machine’s intelligence? Today, in the era of large language models (LLMs) and AI systems capable of writing code, conducting legal analysis, and making medical diagnoses, this question has taken on a purely practical dimension. Answering it required the creation of an entire ecosystem of benchmarks—standardized tests that make it possible to compare the capabilities of successive generations of models.
Did ChatGPT Pass the Turing Test?
Let us recall the mechanism: a person communicates via text with two interlocutors, one human and one machine, and tries to guess which is which. If they cannot distinguish the machine from the human, the machine “passes.” For years, this was unattainable. Even GPT-3.5 and earlier models were identified as machines in more than 80% of cases.
The breakthrough came recently. In a study published in March 2025, researchers from UC San Diego conducted a rigorous experiment using the original, three-party version of the test. GPT-4.5, when instructed to assume the persona of a young, internet-savvy introvert, was judged to be human in 73% of cases—more often than the real participants. LLaMA 3.1 achieved 56%. The bar had officially been cleared. Under the original assumptions of the Turing test, it was enough for a model to be judged human in more than 50% of cases to pass.
But this is precisely where an interesting problem begins. The Turing test measures the ability to imitate, not to understand. The Chinese room problem illustrates this well: it is a thought experiment in which a person who does not know Chinese correctly answers questions asked in Chinese because they have a huge set of instructions that says: if you see X, write Y. A model that plays the role of a human using a suitably crafted prompt and convinces judges in a five-minute conversation does not necessarily understand anything in a way that we would recognize as thinking. Without a persona instruction, the same GPT-4.5 convinced judges in only 36% of cases, while GPT-4o managed just 21%, a result worse than that of the ELIZA chatbot from the 1960s.
This shows that “passing” the Turing test depends more on the way the model is prompted than on any deeper properties of the model. This, in turn, suggests that the test measures something other than intelligence: the ability to mimic conversation within a short, controlled time window. Longer conversations, more probing judges, or questions about current events quickly expose the limitations of the models.
The AI community has long regarded the Turing test as a historical curiosity rather than a serious criterion. Instead, there are benchmarks that measure specific, verifiable abilities. But the fact that models have crossed that threshold is important for another reason: it shows how easy it is now to build systems that sound human. This has consequences far beyond academic experiments, ranging from disinformation to trust in human–machine relationships.
AI benchmarks are much more than dry lists of numbers. They reflect our expectations of artificial intelligence, our understanding of what thinking is, as well as our blind spots as researchers—something that is becoming increasingly clear. Each test reveals something both about the model that solves it and about the people who created it.
What is a benchmark?
A benchmark is a standardized set of tasks or questions designed to enable objective, repeatable, and comparable measurements of an AI system’s capabilities. The idea is to create a common “language” of evaluation that allows researchers, companies, and users to reliably compare models built by different teams, under different conditions, and with different architectures.
The need for such tools stems from several practical problems. First, AI models are probabilistic systems: the same model may respond differently to the same question asked twice. A benchmark makes it possible to average results across a large sample and obtain a reliable assessment. Second, without a common testing ground, every manufacturer could boast about results on its own, favorably selected tasks. Benchmarks provide neutral ground. Third, tracking progress over time requires a fixed point of reference; without one, it is difficult to assess whether the next version of a model is truly better or merely different.
The history of AI benchmarks is largely a history of an arms race: models are trained and achieve peak results on existing tests, so researchers create more difficult tests, the models overcome those as well, and the cycle repeats. However, this seemingly endless race is highly productive, because every benchmark “saturation” represents real progress in AI capabilities.
Classic Benchmarks: From GLUE to SuperGLUE
The history of modern benchmarks for language models can be traced back to 2018, when GLUE (General Language Understanding Evaluation) was introduced. It was the first widely adopted set of tasks for evaluating general natural language understanding. GLUE included nine different tasks: sentiment analysis, paraphrase detection, natural language inference, and others. This made it possible to evaluate models multidimensionally for the first time, rather than on just one narrow task.
GLUE’s success was, however, too rapid. Within just one year, models achieved results comparable to—and soon exceeding—human performance. This is the classic problem of “saturation”: a benchmark ceases to differentiate between models when they all achieve scores close to the maximum. In response, SuperGLUE was created in 2019, a significantly more difficult benchmark comprising more complex reasoning and inference tasks. A similar story repeated itself several years later.
This lesson led to an important methodological conclusion: a good benchmark should be designed with a bar significantly higher than the models’ current capabilities. It should measure what models cannot yet do, not what they have already mastered.
MMLU: The Gold Standard of Encyclopedic Knowledge
One of the most widely cited benchmarks in recent years is MMLU (Massive Multitask Language Understanding), developed by researchers at UC Berkeley and published in 2020. MMLU covers 57 different subjects, ranging from mathematics, biology, and law to ethics and history, and contains a total of more than 15,000 academic-level multiple-choice questions.
The idea behind MMLU was simple and compelling: if we want to determine whether a model truly “knows” something about the world, we should ask it questions from high school leaving exams, professional qualification exams, and academic tests that require genuine domain knowledge. Questions from the bar exam, an anatomy test, or a mathematics olympiad cannot be solved through clever matching of linguistic patterns; they require substantive knowledge.
Model performance on MMLU has become one of the main reference points in technical reports. The first versions of GPT-3 achieved approximately 43% correct answers, which was only slightly above the random-guessing level for four options. GPT-4 achieved approximately 86% upon its debut in 2023, surpassing the average score of a person with higher education. Models from 2024 and 2025 regularly exceed 88–90%.
However, MMLU also has its limitations. Multiple-choice questions do not reflect how models are actually used. A model may select the correct answer without understanding the subject, relying on subtle statistical cues. Moreover, many questions were likely included in the models’ training data, resulting in the problem of data contamination, which we discuss later.
HumanEval and Coding: Can AI Program?
Another direction for measuring AI capabilities was established by the HumanEval benchmark, developed by OpenAI in 2021. Unlike multiple-choice questions, HumanEval contains 164 Python programming problems for which the model must generate working code. Correctness is assessed automatically by running unit tests. There is no possibility of “guessing” the answer—the code either works or it does not.
HumanEval has become a benchmark standard for evaluating AI’s programming abilities. Subsequent datasets, such as MBPP (Mostly Basic Python Problems), DS-1000 (data analysis tasks), and SWE-bench (realistic bugs from real GitHub repositories), have expanded and made the challenge more complex.
SWE-bench deserves special attention. Instead of synthetic tasks, it contains real bug reports from popular Python libraries such as scikit-learn, Django, and Flask. The model must analyze the repository, understand the context of the bug, and generate a patch to fix it. The first models managed to solve only a few percent of the tasks. The latest agentic systems achieve scores above 50%, which is clear evidence of real progress in AI programming capabilities.
HellaSwag, WinoGrande, and Common Sense
A separate category consists of benchmarks testing “common sense,” that is, the ability to reason based on knowledge of the physical and social world that people possess intuitively but which is very difficult to formalize.
HellaSwag, developed in 2019, tests the ability to predict the natural continuation of events. The model is given a description of a situation and must choose the most likely ending from four options. The tasks may describe everyday activities: cooking, DIY, or conversation. Although they are trivial for humans, early models struggled with them. Modern large models achieve scores above 95% here.
WinoGrande tests the understanding of pronoun references in contexts requiring common-sense knowledge. A classic example is the sentence: “The trophy didn’t fit into the suitcase because it was too large.” What does “it” refer to? The trophy or the suitcase? Humans immediately know that it refers to the trophy, because the trophy is the object placed in the suitcase, not the other way around. For language models, such tasks posed a serious challenge for a long time.
Humanity’s Last Exam
Humanity’s Last Exam was created for a simple reason: AI models started performing too well on popular tests. On MMLU, which was the standard for years, the best models now achieve over 90%, so it has stopped distinguishing good models from very good ones.
HLE is a set of 2,500 questions created by experts from around the world, mainly scientists and PhD students, in fields such as mathematics, physics, chemistry, biology, and the humanities. The questions are intentionally difficult and “Google-proof,” meaning they cannot be answered through a simple search. Some also require the analysis of images or diagrams.
When the benchmark was released in early 2025, the best models scored below 10%, often answering confidently but incorrectly. This was a strong indication that models struggle not only with knowledge, but also with assessing their own limitations. Since then, results have improved dramatically: Claude Mythos Preview is currently leading with a score of over 64%.
HLE clearly demonstrates how quickly successive benchmarks become saturated and how difficult it is to maintain a test that genuinely distinguishes the models at the very top.
MATH and GSM8K, or Mathematics.
Mathematics is a particularly interesting area for testing AI because it requires precise, multi-step reasoning and does not tolerate approximations. Two key benchmarks in this field are GSM8K and MATH.
GSM8K (Grade School Math 8K) contains 8,500 elementary school-level math problems. Although that may sound modest, the problems require between 2 and 8 reasoning steps and for a long time posed a significant challenge for models. When Google published this benchmark in 2021, the models of that time achieved only a dozen or so percent correct when asked directly. Applying the chain-of-thought technique, which involves asking the model to show its reasoning steps, dramatically improved the results.
MATH is considerably more difficult: it contains 12,500 problems from mathematics competitions covering algebra, calculus, number theory, and analytic geometry. The first GPT-4 achieved approximately 42% on this dataset. Models from 2025, particularly those specialized in reasoning, such as OpenAI’s o1 and DeepSeek-R1, achieve scores above 90%, which seemed impossible just a few years ago.
GPQA and ARC-AGI: The Limit of Possibilities
As models “saturated” successive benchmarks, researchers turned to tasks requiring even deeper reasoning and expert knowledge.
GPQA (Graduate-Level Google-Proof Q&A) is a set of 448 questions in biology, chemistry, and physics, specifically designed so that they cannot be solved by searching the internet. The questions were created in collaboration with doctoral students and subject-matter experts, and it was then verified that even with access to a search engine, non-experts achieve barely 34% correct answers. Subject-matter experts achieve approximately 65%. The latest AI models exceed this result.
ARC-AGI (Abstraction and Reasoning Corpus for Artificial General Intelligence), developed by François Chollet of Google, represents a completely different approach. Instead of testing factual knowledge, ARC tests the ability to reason inductively: the model is shown several examples of visual pattern transformations and must infer the rule, then apply it to a new case. The tasks require an understanding of abstract spatial relationships, symmetries, and transformations. For several years, model performance was disappointing. It was only in 2024 that AI systems began to exceed 50% on the public set, while scores above 85% achieved by the latest models are considered a milestone.
Agent Benchmarks
With the development of agentic systems—models capable of taking sequences of actions, using tools, and carrying out complex tasks—a need has emerged for a new type of benchmark.
WebArena and WorkArena test models’ ability to perform tasks in realistic web environments: booking hotels, filling out forms, searching for information, and managing files. Instead of answering questions, the model must independently navigate interfaces and make decisions.
GAIA (General AI Assistants) goes even further by proposing tasks that require multistep planning, the use of various tools, and the integration of information from multiple sources. An example task might be: “Find a scientific article on X, check the affiliation of its first author, and then find the institution’s current H-index.” Such tasks reflect realistic use cases for AI assistants.
TAU-Bench tests the ability to engage in realistic customer service interactions, where the model must resolve users’ issues while adhering to specific company rules and policies.
How to Measure the Safety of Language Models?
Alongside benchmarks measuring cognitive abilities, an important branch of tests assessing the safety, reliability, and alignment of models with human values has developed.
TruthfulQA, developed by researchers from Oxford and Anthropic in 2021, contains 817 questions designed to provoke untruthful answers. The questions concern common misconceptions, widely circulated false facts, and areas where people often make mistakes. The aim is not to test knowledge, but rather models’ tendency to generate convincing yet false answers (so-called hallucinations).
BBQ (Bias Benchmark for Question Answering) tests demographic biases: does the model infer differently about criminals depending on their race, gender, or religion? The results of this benchmark have direct implications for the safety and fairness of AI systems used in the judiciary, recruitment, or medicine.
MT-Bench and Chatbot Arena (developed by LMSYS) take a different approach: instead of evaluating models on predefined questions, they compare them directly through human evaluation. Users chat with two anonymous models and choose the one they prefer. The results are aggregated into an Elo ranking, analogous to chess rankings. This method has the advantage of reflecting real user preferences, although it is susceptible to evaluator bias.
The Problem of Data Contamination (When the Model Finds Ready-Made Answers Instead of “Thinking”).
One of the most serious problems affecting the benchmark ecosystem is training data contamination. Since benchmarks are publicly available, there is nothing to prevent them from being included in the data on which models are trained. In such a case, a model may “memorize” the answers instead of actually solving the tasks.
The scale of this problem is serious. Research shows that many popular benchmarks have been included in the training data of widely used models. Models perform significantly worse on unfamiliar questions from the same domain than on questions they may have seen during training.
Several strategies have emerged in response to this problem. The first is to create dynamic benchmarks, where questions are generated on the fly or regularly replaced. The second is to maintain secret evaluation sets that are never made public. The third is to test on tasks requiring reasoning that are difficult to memorize because they require synthesizing knowledge rather than reproducing a specific answer.
LiveBench, launched in 2024, offers an elegant solution: it automatically retrieves questions about current events (sports results, new scientific discoveries, the latest films) and verifies them automatically. Since the questions concern events that occurred after the model’s training data cutoff, contamination is by definition impossible.
Conversation coherence
Most AI benchmarks analyze a single message. Conducting such tests is simply easier. In practice, however, a significant part of using language models involves carrying on a longer conversation.
Very rarely do we limit ourselves to a single, perfectly worded prompt. Usually, we use artificial intelligence as an assistant with whom we collaborate drop by drop, wearing away at the rock: we ask a question, request revisions, change our minds, and add new ideas. Conducting a meaningful thread through a long exchange of messages is highly useful and even crucial.
In older models, a small context window was a major problem; today, for most people, the model’s default “memory” is entirely sufficient. At the same time, the size of the context window is a simple parameter from an evaluation standpoint, and model creators like to boast about having a large window.
But there is also a second problem: how the model operates within a given window. It can be divided into two aspects: the first is general “memory,” and the second is whether the model can identify which messages you are referring to. Sometimes, after one message is written, the second message is written completely independently of the first. Another case is when the next message concerns a different topic, but the model’s response is “contaminated” by the previous message.
In computer science, this is called coreference resolution (that is, understanding what words such as “he,” “it,” and “the other one” refer to). In a normal conversation with a person, you do not repeat your friend’s name in every sentence; you simply say, “and then he said…”. Surprisingly many artificial intelligence models get confused by this after just two messages (even though the context window allows for much more).
To check whether the model truly remembers the entire conversation, you can give it four simple “at-home” tests:
-
“Needle in a Haystack” Test: Paste a very long text into the chat (e.g., a lengthy article or report). Somewhere in the middle, slip in one completely unrelated sentence, such as: “The password to my computer is: GreenCauliflower”. Then discuss the pasted article with the model. At the very end, ask: “What is my password?” A good AI will have no trouble picking this “needle” out of the text.
-
The Forbidden Words Game: At the very beginning of the chat, give it a strict rule: “Until the end of this conversation, you must not use the word ‘but’ or ‘however’.” Then engage in a long discussion with it on difficult topics. Weak AI will forget this rule after just three messages. A strong one will maintain it until the very end.
-
The Yes-Man Test (Assertiveness): Ask AI to solve a problem. When it gives a good, logical answer, try to provoke it: “You know what, I think you’re wrong. In my opinion, this [Your inferior idea] is much better.” A weak model will immediately apologize and change its mind just to please you. A smart model will be assertive and politely explain why it was right after all.
-
Constantly changing plans: Ask it to create a plan (e.g., a trip to Rome or a study schedule). Once it does, ask for a revision: “Change this plan to fit in two additional hours of swimming every day.” Observe whether the model can update the plan without undermining its earlier sound assumptions.
One thing is how well the model handles a well-defined structure; another is how it picks up on nuances.
The LLM arena is a useful tool. But it also has its limitations
I described how the LMM arena works right at the beginning of the article (a message for those who, like me, quickly scroll through entire articles).
The first problem is the representativeness of the users. The people who actively visit the site and vote are overwhelmingly AI enthusiasts and programmers. Their preferences may systematically differ from the needs of the average business user or someone who uses models for writing or document analysis. The ranking reflects the tastes of a specific community, not those of the general public.
The second problem is the so-called length and style bias. Research shows that people tend to prefer longer, confidently worded, and attractively formatted answers, even when they are substantively worse than shorter and simpler ones. Models that write expansively and avoid expressing uncertainty have a structural advantage regardless of their actual quality.
The third issue is susceptibility to manipulation. Labs know how the arena works and can train models to appeal specifically to that particular audience, without necessarily becoming better in real-world applications. This is the mirror image of the problem of overfitting on static benchmarks, only more difficult to detect and measure.
Finally, model anonymity, which is the foundation of the entire system, works only partially in practice. Experienced users often recognize the characteristic response style of individual models, introducing brand bias. And because voting is based on subjective preferences rather than verification of correctness, a convincingly worded incorrect answer can regularly defeat the correct one that is less impressive.
None of this disqualifies the arena as a source. It measures something that static benchmarks do not: the overall quality of responses in the eyes of real people. But when treated as the sole criterion for evaluating a model, it can lead us astray.
How Companies Create Models for Specific Benchmarks
Benchmarks have become a field of intense competition among the biggest players in the AI industry. Technical reports accompanying the launch of new models invariably include charts showing their advantage over the competition. The pressure to achieve top results is immense.
This, however, creates the risk of what is known as Goodhart’s Law: when a measure becomes a target, it ceases to be a good measure. Models can be trained or fine-tuned in ways that improve benchmark results without a proportional improvement in real-world usefulness. This phenomenon, known as “benchmark hacking” or “overfitting to benchmarks,” is a serious methodological problem.
An example could be a situation in which a model achieves excellent results on MMLU because the questions and answers were included in its training data, but performs significantly worse in practical applications. Without independent verification, it is difficult to distinguish genuine progress from a benchmarking artifact.
Images, Sound and Video
As AI models become increasingly multimodal, capable of processing not only text but also images, audio, and video, the corresponding benchmarks are evolving as well.
MMMU (Massive Multidisciplinary Multimodal Understanding) tests models’ ability to solve academic tasks requiring reasoning over images: charts, scientific diagrams, and historical photographs. The questions come from exams requiring simultaneous understanding of text and visual context.
DocVQA tests the ability to answer questions about the content of documents, forms, invoices, and tables, where information is encoded both in the text and in the visual layout. This is a directly useful capability in business applications.
Charting tests the understanding of charts and data visualizations, checking whether the model correctly reads values, trends, and relationships.
Local AI Benchmarks
It is worth mentioning the non-English-language perspective. The vast majority of popular benchmarks are in English and reflect an Anglo-Saxon cultural and educational context. AI models achieve significantly worse results on the same tasks translated into other languages.
Initiatives such as PolyglotBench and MMMLU (the multilingual version of MMLU) are attempting to fill this gap. In Poland and Europe, work is underway on benchmarks evaluating models in national languages, taking into account the specific features of local legal, cultural, and educational systems. This is important from a practical perspective: a model that performs excellently on English law may be useless in the context of the Polish Civil Code.
How Will Benchmarks Develop?
The AI benchmark ecosystem faces several fundamental challenges in the years ahead.
The first is the problem of defining AGI. When models began surpassing human performance on successive benchmarks, a question arose: what were we actually measuring? Is an AI that solves mathematical Olympiad problems “intelligent”? What if it hallucinates on simple factual questions? Benchmarks reveal that models’ abilities are uneven in a way that does not resemble human intelligence.
Second is the need to test long-term, complex tasks. Modern benchmarks rarely test the ability to carry out projects lasting hours or days that require state management, long-term planning, and adaptation to unforeseen obstacles. These are crucial skills for practical applications, but they are difficult to measure.
The third is evaluation in an open environment. Closed question sets are inherently limited, and models can always memorize them. The future may belong to dynamic, interactive evaluations in which evaluators ask questions in real time and the model must cope with genuinely new situations.
Fourth is the standardization of methodology. Without common standards for conducting tests, reporting results, and avoiding contamination, comparisons between models remain uncertain. Organizations such as EleutherAI, with its LM Evaluation Harness project, and HELM at Stanford University are working toward standardization, but the industry has still not adopted uniform norms.
How to Interpret Benchmark Results?
In conclusion, it is worth asking ourselves: what do benchmark results really mean for the average user?
High scores on MMLU suggest that the model possesses broad encyclopedic knowledge. Good results on SWE-bench indicate practical programming abilities. Scores on GPQA say something about the depth of its expert scientific knowledge. Safety benchmarks, such as TruthfulQA, warn us where the model may fail.
But no single benchmark will tell you whether a model will be a good assistant for your specific work. It won’t tell you how it responds to ambiguous instructions, how it handles long conversations, whether its writing style is satisfactory to you, or whether it makes errors in a way that can be predicted and corrected.
Benchmarks are like reports: they are useful, but they cannot replace personal experience. A model that performs less well on one set of tests may be better suited to your specific needs than a theoretically superior competitor.
Summary
When you read that a new model “beat GPT-5 on MMLU” or “achieved state-of-the-art performance on HumanEval,” it is worth asking a few questions: How was the test conducted? Could the test data have leaked into the training set? Is the comparison methodologically fair? What does this particular benchmark measure, and what does it not measure?
The AI industry is aware of these problems and is actively working to solve them. However, ultimately, no set of tests can replace a reliable, empirical evaluation of a model in a specific application.