Why LLMs Hallucinate

What a hallucination actually is

An LLM hallucination is a confident, fluent output that is factually wrong or unsupported by any real source — a fabricated citation, a nonexistent API method, a plausible-sounding but invented historical date. The term is a bit misleading: the model isn't malfunctioning or having a perceptual error the way the word implies. It's doing exactly what it was built to do — predict the most statistically likely next token — and that process simply has no built-in mechanism for verifying truth.

Understanding hallucination requires understanding what an LLM fundamentally is: a next-token predictor trained on text, not a database, not a search engine, and not a reasoning system with access to ground truth. Everything it produces is generated from learned statistical patterns, and those patterns can produce a false statement with exactly the same fluency and confidence as a true one.

Cause 1: Next-token prediction has no grounding

An LLM generates text one token at a time, each token chosen based on how probable it is given everything before it. This process has no built-in fact-checking step, no query to a source of truth, no internal flag that says "I am not sure this is correct." If a fabricated fact is a statistically plausible continuation of the sentence so far — grammatically correct, stylistically consistent, thematically on-topic — the model will generate it exactly as readily as a true fact with the same shape.

This is the core structural reason hallucination is not a bug to be patched away entirely: it's a direct consequence of how generation works. A model asked for a citation it doesn't actually know will often generate one that looks exactly like a real citation — plausible author names, a plausible journal, a plausible year — because that's what a citation-shaped sequence of tokens looks like, whether or not the specific facts are real.

Cause 2: Gaps and errors in training data

LLMs learn from massive but finite and imperfect text corpora. For any given question, the model may have seen: abundant, consistent, correct information (it will likely answer well); sparse or conflicting information (it may blend or guess); or no relevant information at all (it will still generate an answer, because generating an answer is what it does, and that answer will be built from pattern-completion rather than retrieved fact).

This is especially visible with niche topics, recent events past the training cutoff, and specific numeric or factual details that appeared rarely in training — page numbers, exact statistics, obscure API parameters, minor historical figures. The model has learned the general *shape* of confident, well-formed answers far more reliably than it has memorized the specific facts that would make any given answer correct.

Cause 3: Sycophancy and training incentives

Modern LLMs are refined after pretraining using human feedback (RLHF and related techniques), which trains the model to produce responses that human raters rate highly. This introduces a subtler cause of hallucination: sycophancy — a tendency to tell users what they seem to want to hear, agree with a user's stated premise even when it's false, or confidently answer a question rather than admit uncertainty, because confident, agreeable, complete-sounding answers tend to score better with raters than hedged or incomplete ones.

A user who asks a leading question ("Isn't it true that X happened in 1990?") can sometimes get an LLM to confirm a fabricated premise, not because the model "believes" it, but because agreement is often the locally higher-scoring continuation. This is a training-incentive problem layered on top of the structural grounding problem — even a model with genuinely accurate underlying knowledge can be nudged toward confidently wrong output by the shape of the conversation.

Mitigation: Retrieval-Augmented Generation (RAG)

The most effective practical mitigation is to stop asking the model to recall facts from memory at all, and instead give it the facts directly in context. Retrieval-Augmented Generation retrieves relevant documents from a trusted knowledge base at query time and inserts them into the prompt, so the model's job shifts from *recalling* information to *summarizing or reasoning over* information that's right in front of it — a task LLMs are considerably more reliable at.

RAG doesn't eliminate hallucination entirely (a model can still misread or misquote the retrieved context, or fall back on prior knowledge when the retrieved documents don't fully answer the question), but it dramatically reduces it for knowledge-intensive tasks by replacing "trust the model's memory" with "trust a retrieval system plus the model's ability to read."

Other mitigation techniques

Citations and source attribution: requiring the model to cite specific sources for factual claims makes hallucinations easier to catch — a claim with no matching source, or a citation that doesn't actually support the claim, is a visible red flag rather than a silent error.

Confidence calibration: training or prompting models to express appropriate uncertainty ("I'm not certain, but...") rather than uniform confidence, so users can weight claims accordingly. This remains an active research problem — LLMs are often poorly calibrated, expressing similar confidence for well-supported and fabricated claims alike.

Structured verification and tool use: letting the model call a calculator, run code, or query a database for factual lookups rather than generating numeric or factual answers from memory — offloading the parts of a task where recall accuracy matters most to a system actually built for that.

Constrained decoding and self-consistency checks: sampling multiple independent answers to the same question and checking for agreement, or restricting output to match a verified schema, both of which catch some but not all hallucinations.

Hallucination causes and their primary mitigations

What's next

RAG is the single most effective mitigation for hallucination, and it deserves its own deep dive into how retrieval actually works — chunking, embeddings, vector search, and re-ranking. If you haven't read the RAG lesson yet, that's the natural next step from here.