There’s a genuinely strange pattern in the last two years of AI progress. As models have gotten better at reasoning, better at coding, better at math, several of them have gotten measurably worse at not making things up. The newer, more capable model hallucinates more than the older, simpler one it replaced, on the same basic factual test. This isn’t a rumor or a vibe, it shows up in the model makers’ own numbers, and it’s one of the most revealing things about how these systems actually work. Here’s what the data shows, and the honest explanation for why smarter has, in specific ways, meant less reliable.
Start with the number that made people stop and stare. When one major lab tested its flagship reasoning model against the older reasoning model it was replacing, on a standard benchmark that asks factual questions about real people, the older model gave a wrong, made-up answer about 16 percent of the time. The newer, more advanced, more expensive model that was supposed to be better. It made things up 33 percent of the time. Roughly double. And a smaller, faster sibling model did worse still, hallucinating on nearly half of the same questions, and on a different factual test, it invented answers around 79 percent of the time.
Let that land, because it inverts the story everyone tells about AI. The assumption baked into every model launch is that newer means better across the board. And in many ways these models genuinely are better, they reason more carefully, they write better code, they solve harder math. But on the specific axis of stating true facts and not fabricating, several of the most advanced models have moved backward. The lab that built them, in its own technical report, said plainly that more research is needed to understand why this happens as they scale up reasoning. When the people who built the model tell you they are not entirely sure why it makes things up more than its predecessor, that’s worth understanding. It’d be easy to write this off as one lab’s quirk, but the pattern shows up across the field, which is what makes it interesting rather than anecdotal.
Take an open-weights model family from another major developer. The reasoning version of the model hallucinated about 14 percent of the time on an independent summarization benchmark, while the plain base version from the same company, built on the same foundation, hallucinated under 4 percent of the time. That’s close to a fourfold difference, and the only meaningful change was adding the reasoning behavior. The reasoning model also produced far more of what researchers call benign hallucinations, plausible-sounding details it added that were not actually in the source, around 72 percent of its responses containing such additions versus 37 percent for the base model.
The next generation of that same family pushed the pattern to an extreme. The newer models scored near the top of open-weights leaderboards for coding and agentic tasks, genuinely capable systems, while posting hallucination rates on a broad factual benchmark in the mid-90s percent range, among the highest ever recorded. Strong capability, almost no calibration, sitting in the same model. The reasoning gains and the factual unreliability arrived together, in the same release, which strongly suggests they’re connected rather than coincidental.
So this is not a story about one company shipping a bad model. It’s a pattern that recurs across labs and architectures whenever the same basic move is made, taking a model and training it to reason more elaborately before answering. Something about that move, which clearly helps with math and code, hurts with plain factual accuracy. The question is what.
The model makers frame the cause as not fully understood, and the precise mechanics are genuinely still being researched. But the core of the explanation is actually fairly clear, and it comes from a single line in one lab’s own report that explains most of the paradox. The more advanced model, it noted, tends to make more claims overall, which leads to more accurate claims as well as more inaccurate and hallucinated ones.
Sit with that, because it’s the whole thing in one sentence. A more elaborate reasoning model is more willing to venture, to elaborate, to produce a longer and more detailed answer. A simpler model asked a question it doesn’t know might give a short, hedged, or empty answer. The reasoning model, trained to work through problems step by step and produce thorough responses, says more. And when you say more, you produce more true statements and more false ones at the same time. The rate of fabrication rises not necessarily because the model knows less, but because it asserts more, and a fraction of those extra assertions are wrong.
There is a second, related mechanism that makes this worse specifically for reasoning models. These models work by generating a chain of intermediate steps, reasoning their way toward an answer. When there is a gap in that chain, a step where the model doesn’t actually have the fact it needs, it tends to fill the gap with something plausible rather than stopping and admitting it’s stuck. Each confident step leads to the next, and a small confabulation early in the chain gets built upon rather than caught. Independent researchers testing one flagship reasoning model found it would even invent actions it claimed to have taken while working out an answer, fabricating a process, not just a fact. The step-by-step structure that makes these models good at math also gives fabrication more room to compound.
Underneath both mechanisms is a training incentive that quietly rewards guessing. These models are largely trained and evaluated in ways that reward getting the answer right and penalize saying nothing, but don’t sufficiently reward the crucial act of saying “I do not know.” If a model is graded mostly on whether it produced the correct answer, then when it’s unsure, a confident guess has a chance of being marked right, while an honest abstention is guaranteed to score zero. Over millions of training examples, that math teaches the model to answer rather than abstain, to be confident rather than careful. The result is a system optimized to always have an answer, which is precisely the behavior that produces hallucination when it doesn’t actually know.
Here’s the part that should make you skeptical of any single hallucination statistic, including the striking ones above. The measured rate for the exact same model swings wildly depending on which test you use, which means the headline number is as much about the benchmark as the model.
One current flagship model, in its careful reasoning mode, scored a hallucination rate under 2 percent on a specialized health-focused benchmark, genuinely excellent, while the same model on a different, newer summarization benchmark exceeded 10 percent, distinctly poor. Same model, same week, a fivefold difference in its apparent reliability, driven entirely by what it was asked to do and how the test defined a hallucination. A benchmark of short factual questions about obscure people will produce terrifying numbers. A benchmark of grounded summarization will produce gentler ones. Neither is wrong, they’re measuring different things, but it means a lone hallucination percentage stripped of its benchmark is close to meaningless.
This matters for how you read the whole discussion. When you see a claim that some model hallucinates a certain percentage of the time, the first question is always on what task. The scary 79 percent figure came from a test of short, specific factual recall about people, the hardest possible case for a model relying on parametric memory. It doesn’t mean the model invents four out of five things it ever says. It means that on that specific, punishing test of memorized facts, it failed often. Context is everything, and reporting these numbers without it, which happens constantly, produces far more alarm or comfort than the data supports.
There’s a genuinely counterintuitive wrinkle worth knowing, because it cuts against the simple story that scale causes hallucination. In several comparisons, a smaller model has posted a lower hallucination rate than a larger, more capable one from the same family. On its face that supports “bigger hallucinates more.” But the reason is subtle and it’s not that the small model is wiser.
A smaller, less capable model often has a lower hallucination rate partly because it attempts less and covers less ground, and a model that ventures fewer claims has fewer chances to be wrong. A tiny model that mostly handles simple queries and declines or fumbles the hard ones can post clean hallucination numbers precisely because it is not capable enough to get into trouble. So a low hallucination rate isn’t automatically a sign of a trustworthy model, it can be a sign of a limited one. The honesty that matters is not saying little, it’s knowing the boundary of what you know and stating it, and that calibration is a distinct capability that doesn’t come free with either size or reasoning skill. Some models have it and some don’t, largely independent of how smart they otherwise are.
This is why the useful question is not “how big is the model” or even “does it reason,” but “is it calibrated,” does it know what it doesn’t know and act accordingly. A well-calibrated large model and a well-calibrated small model are both trustworthy in their range. A poorly calibrated model of any size will confidently mislead you, and the current frontier has produced some extremely capable, extremely poorly calibrated models, which is the uncomfortable heart of the whole issue.
Step out of the benchmarks and into practice, because the paradox has direct consequences for anyone relying on these models for real work.
The first practical takeaway is that capability and reliability are separate axes, and you can’t infer one from the other. A model that tops the coding leaderboards may be exactly the wrong choice for a task where inventing a plausible false fact is costly, like legal, medical, or financial work. The most advanced model isn’t automatically the safest one for accuracy-critical tasks, and in some documented cases it is measurably worse. Choosing a model means looking at calibration and task-specific factuality, not just the headline capability scores, and those are often reported in completely different places, if at all.
The second is that grounding the model in real sources is the most effective mitigation available, which connects directly to why retrieval and search matter so much. When a model can look up the answer in provided documents rather than reciting from memory, hallucination drops sharply. The same underlying model that fabricates when asked to recall a fact from memory becomes far more reliable when handed the relevant text and asked to answer from it. This is exactly why answer engines and retrieval systems exist, they attack the hallucination problem at its root by not asking the model to be a database in the first place. If accuracy matters, the architecture that feeds the model real sources is worth more than chasing the highest-capability model.
The third, and most important for daily use, is a mindset. These aren’t knowledge oracles, they are fluent reasoning engines with imperfect and uneven recall, and the more fluent and confident they get, the more convincing their mistakes become. A hesitant wrong answer is easy to catch. A beautifully reasoned, confidently stated wrong answer from an advanced model is genuinely dangerous precisely because it is so persuasive. The improving quality of the writing doesn’t track the accuracy of the facts, and treating fluency as a proxy for correctness is the single most common way people get burned by these tools.
The hallucination paradox isn’t a scandal or a sign that AI progress is fake. The models really are getting more capable, and the reasoning advances are real. What the paradox reveals is that “capability” was never one thing. The ability to reason through a hard problem and the ability to know the limits of your own knowledge are different skills, and the field has been optimizing hard for the first while the second has lagged, and in some cases regressed. A model can become genuinely smarter and genuinely less reliable at the same time, because those two qualities live in different parts of what the model does.
The encouraging part is that once the problem is named correctly, as a calibration gap rather than a mysterious defect, it becomes addressable. Training methods that reward honest uncertainty, evaluations that stop punishing abstention, and architectures that ground answers in real sources all attack it directly, and the labs are actively working on all three. The likely path forward isn’t smaller or dumber models, but models explicitly taught the thing the current generation was never rewarded for, the discipline of knowing, and saying, when they do not know. Until that catches up, the practical wisdom is simple. The smarter these models sound, the more deliberately you should check what they tell you, because sounding right and being right are, for now, still two different things.
Hallucination rates cited here come from model makers’ own technical reports and from independent benchmarks, and they vary enormously by test, so treat any single percentage as specific to its benchmark rather than a universal property of the model. This is a fast-moving area of active research, and the specific figures reflect testing reported through 2026.
Why Smarter AI Models Hallucinate More, Not Less was originally published in Towards AI on Medium, where people are continuing the conversation by highlighting and responding to this story.