The most dangerous thing about a large language model isn’t that it gets things wrong — it’s that it gets things wrong confidently. An LLM will invent a citation, a statistic, a court case, or an API method, and present it in the same fluent, assured tone it uses for facts. This is hallucination, and understanding it is essential to using AI responsibly.
This guide explains what hallucinations are, why they happen, the types you’ll encounter, and the techniques that genuinely reduce them.
Punti chiave
- A hallucination is when an LLM generates information that is false or unsupported, but states it confidently.
- Why it happens: LLMs predict plausible text — they don’t look up facts or know when they don’t know.
- The fix isn’t one thing: grounding with RAG, better prompting, model choice, and verification all help.
- You cannot eliminate hallucination entirely — you reduce it, then verify anything that matters.
- Highest risk: specific facts, citations, numbers, quotes, and niche topics.
What a hallucination actually is
A hallucination is any output an LLM presents as fact that is false, fabricated, or unsupported by its sources. Examples: inventing a research paper that doesn’t exist, citing a fake statistic, attributing a quote to the wrong person, or describing a software function that was never written.
The defining feature is the confidence. The model doesn’t hedge or flag uncertainty — fabricated content reads exactly like accurate content. That’s what makes hallucination genuinely hazardous rather than merely annoying.
Why LLMs hallucinate
To fix hallucination you have to understand its root cause, which lies in how these models fundamentally work.
An LLM is a next-token predictor, not a fact database. It was trained to produce the most plausible continuation of text. It generates language that sounds right based on patterns in its training data — it is not looking anything up. When the most plausible-sounding continuation happens to be false, the model produces it just as readily as a true one. It has no separate “truth check.”
Several factors make this worse:
- No sense of its own knowledge boundary. The model doesn’t reliably know what it doesn’t know. Asked about something outside its training, it generates a plausible answer rather than saying “I don’t know.”
- Pressure to answer. Models are trained to be helpful and responsive, which biases them toward producing an answer over admitting ignorance.
- Gaps and errors in training data. If information is sparse, contradictory, or wrong in the training data, the model’s output reflects that.
- Knowledge cutoff. Anything after the training date simply isn’t there — so the model fills the gap by guessing.
- Lost context. In long conversations or documents, the model can lose track of details and “fill in” incorrectly.
The main types of hallucination
| Tipo | What it looks like |
|---|---|
| Factual fabrication | Inventing events, statistics, or facts that don’t exist |
| Fake citations | Producing realistic but non-existent papers, books, or URLs |
| Misattribution | Assigning a real quote or idea to the wrong person |
| Context contradiction | Answering against the documents you actually provided |
| Logical/numerical errors | Confident mistakes in math or reasoning chains |
| Code hallucination | Calling functions, libraries, or parameters that don’t exist |
How to reduce hallucinations
No single technique solves it. Reliable AI systems layer several defenses.
1. Ground the model with RAG
The most effective structural fix is generazione con recupero aumentato (retrieval-augmented generation): retrieve relevant source documents and instruct the model to answer only from them. This swaps “recall from memory” for “read from a source” and sharply cuts fabrication — especially for facts and citations.
2. Prompt for honesty
Explicitly give the model permission to be uncertain: “If you don’t know, say so. Don’t guess.” Ask it to cite sources, to separate facts from inferences, and to flag low-confidence parts. This won’t stop hallucination alone, but it measurably helps.
3. Provide the source material directly
If you have the document, paste it into the prompt rather than relying on the model’s memory of it. A model summarizing text you supplied is far more reliable than one recalling text it saw in training.
4. Choose the right model
Larger, newer frontier models hallucinate less than small or older ones. Reasoning-focused models tend to be more accurate on logic and math. For factual, high-stakes work, use a strong model and, where possible, one with live search or retrieval built in.
5. Ask for verification
Have the model — or a second model — review the first answer: “Check the response above for any claims that might be inaccurate or unsupported.” Self-critique catches a meaningful share of errors.
6. Verify anything that matters
The final and non-negotiable layer is human verification. For any specific fact, citation, number, quote, legal point, or medical claim, check it against a primary source. Treat the LLM as a fast, knowledgeable, occasionally unreliable assistant — never as a final authority.
When to be most careful
Hallucination risk is not uniform. Be especially skeptical of:
- Specific facts: dates, statistics, names, prices, measurements.
- Citations and sources: paper titles, authors, URLs, page numbers — a classic hallucination zone.
- Quotes: exact wording and attribution.
- Niche or recent topics: sparse training data and post-cutoff events.
- Code specifics: exact function names, parameters, and library APIs.
Conversely, LLMs are reliable for explaining well-known concepts, brainstorming, restructuring text, and reasoning over material you supply directly.
How hallucination rates are measured
“Reduce hallucinations” only means something if you can measure them. The catch is that there is no single hallucination score, because there are two very different failure modes, and a model can be excellent at one while failing the other. Knowing which benchmark answers which question is what lets you compare models honestly instead of trusting a marketing claim.
Grounded faithfulness asks: when you hand the model a document and tell it to summarize or answer using only that text, does it stay faithful, or does it invent details? This is the metric that matters for RAG and document workflows. Vectara’s public HHEM leaderboard and Google’s FACTS Grounding both test this. The encouraging news is that on a clean summarization task the best models now sit in the low single digits of percent hallucination, while weaker or older models can be ten times worse, so the choice of model genuinely moves the needle.
Open-recall factuality asks the opposite: with no source provided, how often does the model state a fact correctly from its own memory, and how often does it confidently make one up? OpenAI’s SimpleQA is the standard here, and it is deliberately brutal, full of obscure, easily-falsifiable facts. Even frontier models get a large share of these wrong, which is exactly why ungrounded answers about names, dates, citations, and numbers are the riskiest thing an LLM produces.
The single most useful idea in modern hallucination benchmarks is that a confident wrong answer is worse than an honest “I don’t know.” Good benchmarks grade three outcomes, not two: correct, incorrect, and not attempted. A model that abstains when it is unsure is rewarded, not punished. When you read a leaderboard, weigh that abstention behavior as heavily as raw accuracy.
- For RAG or document tasks: look at a grounding/faithfulness benchmark (HHEM, FACTS Grounding).
- For open Q&A from memory: look at SimpleQA-style factuality and at how often the model abstains.
- For your own use case: public scores are a starting point, not a verdict. Build a small set of 30 to 50 real questions from your domain, with known correct answers, and grade each model yourself. A model that tops a generic leaderboard can still hallucinate on your specific jargon.
Domande frequenti
What does it mean when an AI hallucinates?
It means the AI generated information that is false or unsupported but presented it as fact, with full confidence. Examples include inventing statistics, fabricating citations, or describing software functions that don’t exist.
Why do LLMs hallucinate?
Because they are next-token predictors, not fact databases. They generate the most plausible-sounding continuation of text based on training patterns — they don’t look facts up and have no built-in truth check. When a false statement is the most plausible-sounding one, the model produces it confidently.
Can hallucinations be completely eliminated?
No. They can be greatly reduced through grounding (RAG), careful prompting, strong model choice, and verification — but not eliminated entirely, because hallucination stems from how LLMs fundamentally work. The right approach is to minimize it and then verify anything important.
Does RAG stop hallucinations?
RAG significantly reduces them by giving the model real source documents to answer from, instead of relying on memory. It’s the most effective single technique. But it isn’t perfect — poor retrieval or a model ignoring its context can still produce errors.
How do I know if an AI answer is a hallucination?
You often can’t tell from the answer alone — hallucinations read exactly like correct answers. The only reliable method is verification: check specific facts, citations, and numbers against primary sources. Be most suspicious of precise details and niche or recent topics.
Which AI models hallucinate the least?
It depends entirely on the task. On grounded summarization (the Vectara HHEM leaderboard), the leading models hold hallucination rates in the low single digits of percent, and the frontier models from OpenAI, Google, and Anthropic are all competitive. On open-memory factual recall (SimpleQA) the same models perform far worse, because there is no source document to anchor them. Always check the benchmark that matches how you will actually use the model rather than a single headline number.
Do reasoning models hallucinate less than standard models?
It depends on the task, and the popular assumption that “thinking” models are always safer is wrong. On grounded summarization, reasoning models often hallucinate altro: the extra reasoning leads them to add inferences and connections that go beyond the source, so several frontier reasoning models sit above 10% on Vectara’s harder leaderboard while lighter non-reasoning models score in the low single digits. Where reasoning genuinely helps is open-memory recall, and even there the gain is mostly self-awareness rather than knowledge: the model recognizes it is unsure and abstains instead of guessing, which lowers confident false answers. Extra reasoning cannot invent a fact the model never learned. The practical rule is to favor reasoning for analysis and diagnosis, but not to assume it for faithful summarization or extraction.
How can I measure hallucinations on my own data?
Build a small evaluation set. Collect 30 to 50 real questions from your domain where you already know the correct answer, run each candidate model, and label every response correct, incorrect, or abstained. Track confident-wrong answers separately, since those are the dangerous ones. If you use RAG, also check whether each answer is actually supported by the retrieved text. This homemade benchmark will tell you more about your real risk than any public leaderboard.
Conclusione
Hallucination is not a bug that a patch will fix — it’s a direct consequence of how language models work. They predict plausible text; they don’t verify truth. That’s why even the best 2026 models still occasionally fabricate with total confidence.
The practical response is layered: ground the model with RAG, prompt it to admit uncertainty, give it source material directly, use a strong model, and — above all — verify anything that matters. Used that way, LLMs are extraordinarily useful. Trusted blindly, they are a liability. The skill is knowing the difference.