Is hallucination going away with bigger models?

Reduced, not eliminated. Larger models hallucinate less on common topics but still confidently invent details on edge cases. As of 2026, frontier models hallucinate noticeably less than older models, but the fundamental mechanism — generating plausible text without a built-in fact-check — remains. Even the best models will invent paper titles, statistics, quotes, or product specs when prompted in their weak spots. Grounding the model with retrieved facts (RAG, web search) is what actually drives hallucination down for practical use.

What's RAG / grounding / retrieval?

Retrieval-Augmented Generation: instead of asking the model to answer from memory, you first retrieve relevant text (from a search engine, a knowledge base, or your own documents) and pass it to the model along with the question. The model then answers based on the retrieved text rather than from training memory alone. This dramatically reduces hallucination because the model can ground its answers in specific text. Tools like Perplexity, Bing Chat, and Google AI Mode all use grounding heavily. Most enterprise AI applications use RAG patterns.

How do I tell when an AI is hallucinating vs being correct?

You usually can't from confidence alone — AI is confidently wrong at the same prose-quality as confidently right. Signs to be alert: specific numbers, dates, quotes, names, and citations are the highest-risk claims. Generic principles and broadly-known facts are usually fine. The reliable defence is to verify any claim that matters against a primary source you trust. For routine drafting and brainstorming, hallucination matters less; for anything you'll act on or publish, verification is non-negotiable.

Why AI Hallucinates — And How to Catch It

As of 2026-05-18. Hallucination is a moving target — frontier models keep improving, and grounding techniques keep getting better. The principles below are durable; specific tool rankings and capabilities shift. For current technique guides, see thepromptbench.com.

What hallucination actually is

When an AI assistant confidently states something that's false — a wrong date, a non-existent paper, an invented quote, a fictitious product specification — we call it a hallucination. The term is borrowed from psychiatry but used differently: an AI hallucination isn't a perception of unreal stimuli; it's the production of plausible-sounding text that isn't grounded in fact.

A few examples that have actually happened:

A lawyer submitted a brief citing court cases that didn't exist. ChatGPT had fabricated the citations with realistic-looking case numbers and judge names.
A medical AI summarized a patient record with a diagnosis the doctor hadn't made. The diagnosis was plausible but invented.
A customer-service chatbot promised a refund policy the company didn't have. The promise was a hallucination; the customer (and a tribunal) held the company to it.
A homework helper "summarized" a Wikipedia article that didn't exist, including specific dates and statistics. None of it checked.

These aren't bugs in the conventional sense. The model was working as designed — generating plausible text. The plausibility just happened to include invented specifics.

Why language models hallucinate

To understand why hallucination happens, it helps to understand what these models actually do.

A large language model is trained to predict the next word in a sequence, given the previous words. After training on enormous amounts of text, it gets very good at this. "The capital of France is ___" predicts "Paris" because that pattern was overwhelmingly common in training.

But the model isn't storing facts the way a database does. It's storing probabilities of word sequences. When you ask "What's the capital of France?", the model generates "Paris" not because it looked up a fact, but because "Paris" is the highest-probability completion given that question pattern.

This works perfectly for facts that are extremely well-represented in training. The capital of France, basic arithmetic, common knowledge — all reliable.

It works less well when:

The fact is rare in training data. The capital of a small country, an obscure historical date, a specific paper title — the model has weaker signal.
The question pattern is unusual. Asking for citations in specific formats, asking about edge cases the training data didn't cover.
Multiple plausible answers exist. If the model has seen several variations of a fact, it might generate one of them at random, sometimes the wrong one.
The fact has changed since training. Models have a training cutoff. They don't know what happened after.

In all these cases, the model still generates something — it doesn't have an "I don't know" output by default. It generates the most plausible-sounding completion, even if that completion involves inventing details. From the model's perspective, generating "the 2018 paper by Smith and Jones" is just as valid as generating any other completion, because plausibility is what it was trained on, not truth.

Why "plausible" and "true" diverge

Here's the key insight. Plausibility and truth are different things.

A plausible statement is one that fits its context and follows conventional patterns: well-formed sentences, plausible-sounding numbers, names that look reasonable, citations in the right format. Plausibility is a property of HOW something is said.

A true statement is one that corresponds to reality. Truth is a property of WHAT is said, in relation to the world outside.

A language model is trained on plausibility (predicting fluent text). It's only indirectly trained on truth (because most training text is roughly true, so predicting plausible text correlates with predicting true text). When the correlation breaks down — when the model needs a specific fact it doesn't have stored well — plausibility produces fabrications that look like facts.

This is fundamental to how these models work. It's not a bug that will be fixed by making the model bigger. Bigger models have more facts stored better, so they hallucinate less on common topics. But they still hallucinate at the edges, often with even more confidence because the prose is more fluent.

Where hallucinations especially happen

Pattern recognition for high-risk content:

Specific numbers, dates, prices, statistics. "The unemployment rate was 4.2% in March 2023." Maybe — verify against a primary source.

Specific quotes from named people. "As Warren Buffett said, '..." Often fabricated. Quote attribution is one of the most-hallucinated content types.

Citations and references. "According to a 2021 Harvard study..." The study may not exist. Always check the citation against the actual source.

Names of specific products, models, versions. "The XYZ-3000 has 16GB of RAM." May be a product that doesn't exist, or numbers that are wrong.

Specific URLs. AI will generate URLs that look real but lead nowhere. Don't trust links from AI without clicking them.

Specific historical events. "In 1893, the city of..." May be invented or attributed to the wrong year.

Programming API details. "The function takes parameters X, Y, Z." Some APIs are well-documented in training; others get hallucinated. Always check the actual documentation.

Legal and medical specifics. Statute numbers, dosage amounts, drug interactions. High-stakes hallucinations.

Things involving the AI itself. "My training cutoff is X." "I can't do Y." "I have access to Z." Often wrong.

What's NOT hallucination

Some failure modes look like hallucination but aren't:

Outdated information. If the model says something that was true at its training cutoff but isn't now, that's a freshness problem, not a fabrication. Use grounded search models for current information.

Misunderstood prompts. If the model answers the wrong question, that's a comprehension problem, not a hallucination. Rephrase the prompt.

Reasoning errors on logic problems. If the model gets multi-step arithmetic wrong, that's a reasoning limitation, not invention.

Bias-driven outputs. If the model produces stereotyped or biased text, that reflects training data biases. Different problem with different fixes.

Hallucination specifically is the model producing factual-seeming claims that aren't supported by anything. Be precise about what failure you're seeing — it affects what mitigation to use.

How to mitigate hallucination

Practical techniques, roughly in order of effectiveness:

1. Use grounded search models.

Models that retrieve current information from the web before answering hallucinate dramatically less for factual queries. Perplexity (built around this), ChatGPT with browsing enabled, Claude with web search, Google's AI Mode/Gemini, Bing/Copilot. The grounding doesn't eliminate hallucination but reduces it significantly.

For internal/private information, RAG (Retrieval-Augmented Generation) does the same with your own documents — retrieving relevant context, then asking the model to answer from that context. Most production AI systems use RAG patterns. See thepromptbench.com for the deep dive.

2. Ask for sources explicitly.

"What's your source for that?" or "Show me where this comes from." If the model can't produce a real source, treat the claim as unverified. If it produces a source, check the source exists and says what's attributed.

3. Use lower temperature settings.

If you have access to API parameters: lower temperature (0 to 0.3) reduces creativity and tends to anchor outputs in well-trained patterns. Higher temperature (0.7-1.0) increases creativity but also hallucination risk. For factual queries, use low temperature.

4. Ask the model to qualify uncertainty.

"If you're unsure about any specific fact, say so." Many modern models will respond with explicit uncertainty hedges when prompted. They're far from perfectly calibrated, but it's a real signal.

5. Cross-check across models.

Ask the same factual question to two different models. Disagreement is a signal that at least one is hallucinating; agreement increases (but doesn't guarantee) reliability.

6. Use code execution for math.

Modern AI tools often offer integrated code execution. For arithmetic, calculations, data processing — let the AI write code that actually runs, rather than computing in its head. Pure language models hallucinate numerical answers; code-execution-backed answers are much more reliable.

7. Verify high-stakes outputs against primary sources.

The reliable habit. For anything you'll act on, publish, or rely on, check against an authoritative source.

A specific example: fact-checking with Perplexity Sonar Pro

One concrete pattern, used to verify articles before publishing (including articles on this site):

Write the article without web access — using general knowledge.
Send the article to a grounded model (specifically Perplexity Sonar Pro, which combines a language model with current web search) and ask for fact-checking against current sources.
Receive specific claims flagged as outdated, wrong, or unverifiable, with source URLs.
Apply corrections to the article.

This pattern is used by the editorial team at thepromptbench.com and is being applied to articles here too. The grounded model isn't infallible, but it dramatically reduces fact errors compared to publishing AI drafts unchecked.

The toolchain: OpenRouter (model gateway) + perplexity/sonar-pro (Perplexity's grounded model). Cost is a few cents per article check; time is ~30 seconds. The output is a structured list of findings with source URLs to verify.

A note on benchmarks

You may see hallucination benchmarks like TruthfulQA, HALoGEN, and others. These measure model performance on curated factual questions. Useful for comparing models, less useful for predicting how badly a specific model will hallucinate on your specific use case. Real-world hallucination is task-dependent.

The high-level pattern: hallucination has decreased generation over generation, but it hasn't been solved and probably won't be solved by scale alone. The realistic future is models that use external tools (search, code execution, structured databases) to verify their outputs — making the model less of an oracle and more of a research assistant.

What this means for everyday use

Practical orientation:

For drafting, brainstorming, explaining general topics: hallucination is low-cost. Use AI freely.
For specific facts you'll act on: verify. Always.
For research where citations matter: use grounded models, then check the citations.
For numerical/computational tasks: use code execution, not in-head AI math.
For medical, legal, financial, safety-critical decisions: AI is one input, not the answer. Get domain expert verification.

The general principle: the higher the stakes of a specific factual claim, the more skepticism it deserves.

If you'd like a guided 5-minute course on what AI is doing under the hood when it answers a question, NerdSip can generate one.

The takeaway

Hallucination happens because language models are trained to produce plausible text, not true text. When they don't have a fact stored well, they generate a plausible-sounding fabrication rather than admitting ignorance. This is fundamental, not a temporary bug — though it's been steadily reducing with better models and grounding techniques. The reliable mitigations: use grounded search models (Perplexity, ChatGPT with browsing, Claude with web), ask for sources, verify high-stakes claims, use code execution for math, and cross-check across models. For drafting and exploration, hallucination matters less; for anything you'll act on, treat AI as a starting point and check the specifics.