Why Hallucinations Happen

What “Hallucination” Means in LLM Outputs

In the context of large language models, a “hallucination” is an output that sounds plausible but is not grounded in the user’s provided information or in verifiable reality. It can be a wrong fact, a fabricated citation, an invented name, a misquoted number, or a confident explanation of something that does not exist. The key feature is not creativity; it is unjustified certainty. A model can produce fluent language even when it lacks reliable support for what it is saying.

Hallucinations show up in many forms: (1) factual errors (wrong dates, wrong definitions), (2) fabricated sources (“According to a 2019 paper in…” that doesn’t exist), (3) incorrect reasoning steps (a math derivation with a subtle invalid step), (4) overconfident generalizations (“always,” “never”), and (5) misalignment with the user’s constraints (e.g., claiming it performed an action it cannot perform). Understanding why they happen requires looking at how the model decides what to say next and what information it has available at that moment.

The Core Mechanism: Fluent Prediction Without Built-In Truth Checking

An LLM’s immediate job during generation is to choose the next token that best fits the preceding text. This objective rewards producing sequences that look like the kinds of sequences found in its training data. Fluency and “sounding right” are therefore easy to achieve, while “being true” is only achieved indirectly—when truth correlates with patterns the model has learned.

Hallucinations happen when the model can produce a high-probability continuation that is linguistically and stylistically consistent, but the continuation is not anchored to reliable evidence. In other words, the model can be very good at producing the shape of an answer (tone, structure, typical references, typical numbers) even when the underlying content is missing, ambiguous, or wrong.

A useful mental model: the system is a powerful autocomplete that has seen many examples of how answers are written. If prompted in a way that resembles questions that usually have a specific kind of answer, it may generate that kind of answer even when it should say “I don’t know” or “I need more information.”

Continue in our app.

You can listen to the audiobook with the screen off, receive a free certificate for this course, and also have access to 5,000 other free online courses.

Or continue reading below...

Download the app

Why Hallucinations Are More Likely in Some Situations

1) The Prompt Implies There Must Be an Answer

Many prompts implicitly demand completeness: “List the top 10…,” “Provide the exact steps…,” “Cite three studies…,” “Give me the phone number for…”. If the model does not have enough reliable information, it still faces pressure to produce something that matches the requested format. This can lead to invented details that satisfy the format.

Example: If asked, “Provide five peer-reviewed studies proving X,” the model may generate plausible-looking citations because it has learned what citations look like. The format is easy; the verification is not automatic.

2) Missing or Ambiguous Context Forces Guessing

When a question is underspecified, there are multiple plausible interpretations. The model may pick one interpretation and proceed confidently, even if it is not what the user meant. This can produce an answer that is “reasonable” but wrong for the user’s actual situation.

Example: “How do I reset my account?” Without knowing the service, device, or authentication method, the model may describe steps that apply to a different platform, or it may invent UI labels that sound typical (“Click ‘Security Settings’ → ‘Reset Password’”) even if those labels do not exist.

3) Long, Multi-Part Requests Increase Error Surface

The more claims an answer contains, the more opportunities there are for at least one claim to be wrong. A long response that includes many numbers, names, dates, and steps is statistically more likely to contain an error than a short response. This is not unique to LLMs, but LLMs can produce long, confident text quickly, which amplifies the effect.

4) The Model Blends Similar Patterns (“Pattern Completion Collisions”)

LLMs learn from vast amounts of text where related topics co-occur. When prompted about a topic, the model may blend details from similar topics. This can create hybrid answers: mostly correct structure, but with swapped names, mismatched dates, or conflated concepts.

Example: If asked about one company’s policy, the model might mix in a competitor’s policy because both are often discussed in similar contexts. The output can look coherent while being incorrect.

5) Out-of-Distribution Questions and Niche Domains

When a question is far from what the model has seen frequently—highly specialized technical procedures, obscure local regulations, internal company processes, or very recent events—the model has less reliable learned pattern support. It may still generate an answer that resembles how such answers are usually written, but the details can be speculative.

Internal Drivers: Uncertainty, Probability, and “Confident Tone”

Probability Does Not Equal Truth

During generation, the model selects tokens based on probabilities. A token can be highly probable because it fits the context linguistically, not because it is factually correct. For example, when asked for a date, the model may produce a date-like token sequence that “fits” the narrative. If multiple dates are plausible, it may choose one that appears frequently in similar contexts.

Why the Model Sounds Confident Even When It’s Not

Many training examples contain authoritative writing: textbooks, documentation, Q&A sites, and explanatory articles. The model learns that answers are often delivered in a confident, declarative style. Unless the prompt explicitly invites uncertainty (“If you’re not sure, say so”), the model may default to that style. This is a style prior: the model has learned that “answers” often look confident.

Decoding Choices Can Increase Hallucinations

Generation is not only about the model’s internal probabilities; it also depends on decoding settings. When decoding encourages more diverse outputs (for example, higher randomness), the model is more likely to pick lower-probability tokens. That can be useful for brainstorming, but it can also increase the chance of drifting into unsupported claims. Conversely, very deterministic decoding can lock in a plausible but wrong path once the model starts down it.

Practical implication: the same prompt can yield different factual reliability depending on whether you ask for creativity versus precision, and depending on the system’s generation settings.

Common Hallucination Patterns You Can Learn to Spot

1) Fabricated Citations and Over-Specific References

A classic pattern is a citation that looks real: author names, a year, a journal title, and a DOI-like string. The structure is easy to imitate. If you see citations, treat them as leads to verify, not as proof.

2) “UI Hallucinations” in Software Instructions

The model may invent menu items, buttons, or settings names that sound plausible. This happens because many interfaces share similar vocabulary (“Preferences,” “Advanced,” “Security”), and the model completes the pattern.

3) Numerical Precision Without Justification

Another pattern is unnecessary precision: exact percentages, exact time estimates, or exact thresholds without a source. Precision can create an illusion of authority. If the user did not provide data and the model did not cite a verifiable source, treat precise numbers as suspect.

4) Confident Explanations of Non-Existent Features

When asked about a feature in a product or API, the model may describe endpoints or options that do not exist. This is especially common when the product name is similar to others or when the feature is plausible but not real.

Practical Step-by-Step: How to Reduce Hallucinations When You Use an LLM

The goal is not to eliminate hallucinations entirely (that is not always possible), but to reduce their frequency and to catch them early. The steps below are practical habits you can apply in everyday use.

Step 1: Decide Whether You Need Creativity or Accuracy

• If you need brainstorming, drafts, or alternative phrasings, you can tolerate more uncertainty.
• If you need facts, procedures, legal/medical guidance, or citations, you must constrain the task and verify outputs.

Write your prompt accordingly: “Brainstorm 20 ideas” versus “Answer only if you can support each claim with a source I can verify.”

Step 2: Provide Grounding Material (and Tell the Model to Use Only That)

Hallucinations drop sharply when the model is constrained to a provided text, dataset, policy excerpt, or documentation snippet. Include the relevant material in your prompt and instruct the model to quote or reference it.

Example prompt pattern:

Use ONLY the information in the excerpt below. If the excerpt does not contain the answer, say “Not in the excerpt.” Then answer the question.

This changes the task from “generate a plausible answer” to “extract and explain from given evidence.”

Step 3: Ask for Evidence-First Output

Instead of asking for a final answer immediately, ask for the supporting points first, then the conclusion. This makes it easier to spot unsupported leaps.

Example prompt pattern:

Before answering, list the specific facts you are using (bullet points). For each fact, indicate whether it comes from the text I provided or is an assumption. Then give the answer.

If the model starts listing many “assumptions,” you have an early warning that the answer may be speculative.

Step 4: Force Clarifying Questions When Information Is Missing

Many hallucinations are caused by missing context. You can explicitly require the model to ask questions rather than guess.

Example prompt pattern:

If you need any missing details to answer accurately, ask me up to 5 clarifying questions first. Do not guess.

This is especially effective for troubleshooting, recommendations, and “how-to” instructions.

Step 5: Constrain the Format to Reduce Unnecessary Claims

Open-ended essays invite extra details, which increases the chance of errors. If you only need a small set of verified points, constrain the output.

• Limit the number of bullets.
• Limit the scope: “Only cover steps 1–3.”
• Require short answers: “Max 120 words.”

Example:

Answer in 5 bullets max. Include only steps you are confident are correct. If unsure, mark the bullet as “Needs verification.”

Step 6: Use Adversarial Self-Checking Prompts

You can ask the model to critique its own answer. While this is not a guarantee (the model can miss its own errors), it often catches obvious inconsistencies, missing assumptions, or overconfident claims.

Example:

Now review your answer and identify: (1) any claims that might be wrong, (2) any missing assumptions, (3) what you would verify externally. Then provide a corrected version.

Step 7: Verify the High-Risk Parts First

Not all parts of an answer carry equal risk. Prioritize verification for:

• Proper nouns (people, organizations, product names)
• Numbers (prices, dates, thresholds, statistics)
• Legal/medical/safety instructions
• Citations and quotes

A practical workflow is to copy only the high-risk claims into a checklist and verify them with authoritative sources before using the output.

Practical Step-by-Step: How to Detect Hallucinations in a Draft You Already Have

Step 1: Highlight All Factual Claims

Go through the text and mark every statement that could be checked. If it contains a number, a named entity, a “first/only/best,” or a causal claim (“X causes Y”), treat it as checkable.

Step 2: Classify Each Claim

• Supported: you have a source or provided text that backs it.
• Unsupported: it might be true, but you don’t have evidence yet.
• Unverifiable/likely fabricated: the claim references a source you cannot find or uses suspicious specificity.

This classification helps you decide whether to edit, remove, or verify.

Step 3: Look for “Too Perfect” Structure

Hallucinated content often has a polished, template-like structure: neat lists, perfectly rounded numbers, and citations that all conveniently support the argument. Real-world evidence is messier. If everything lines up too cleanly, verify more aggressively.

Step 4: Cross-Check Internally for Consistency

Even without external sources, you can catch some hallucinations by checking whether the text contradicts itself. Look for:

• Two different numbers for the same quantity
• Conflicting definitions
• Steps that cannot all be true at once (e.g., “do A before B” and later “B must be done before A”)

Why “Just Tell It Not to Hallucinate” Is Not Enough

It is useful to instruct the model to be cautious, but a simple instruction like “Do not hallucinate” does not automatically give the model new information or a verification mechanism. If the model lacks grounding, it may still produce an answer that seems cautious but contains subtle errors, or it may refuse too often. Effective reduction usually comes from changing the task conditions: adding grounding material, requiring clarifying questions, limiting scope, and verifying externally.

Trade-Offs: Helpfulness, Coverage, and Honesty

In many real interactions, users reward helpfulness: they want an answer now. The model is optimized to be useful in conversation, which can bias it toward producing something rather than nothing. This creates a tension between:

• Coverage: answering many questions, even when information is incomplete
• Honesty: admitting uncertainty and asking for more input
• Helpfulness: providing actionable steps

You can shift this balance by explicitly prioritizing honesty: “If you are not sure, say so and ask questions.” When you do, you often get fewer hallucinations but more requests for clarification or more “I don’t know” responses.

Examples: Prompt Tweaks That Change Hallucination Risk

Example A: Citations

Higher risk prompt: “Give me three academic citations proving that remote work increases productivity.”

Lower risk prompt:

I need citations I can verify. If you are not sure a citation exists, do not invent it. Provide: title, authors, venue, year, and a URL. If you cannot find a URL, say “No URL found.”

Even with this, you should still verify, but the prompt reduces the incentive to fabricate.

Example B: Troubleshooting

Higher risk prompt: “My laptop won’t turn on. Tell me what to do.”

Lower risk prompt:

Ask me up to 5 clarifying questions first (model, symptoms, lights, sounds, recent changes). Then provide a step-by-step checklist. Mark any step that could risk data loss.

This reduces guessing and encourages safer, conditional guidance.

Example C: Summarizing a Policy

Higher risk prompt: “What does this company’s return policy say?” (without providing the policy)

Lower risk prompt:

Here is the policy text. Summarize it in 7 bullets. Quote the exact sentence for any bullet about time limits, fees, or exceptions.

Quoting forces grounding and makes it easier to audit.

When Hallucinations Are Actually Useful (and How to Label Them)

Not all “made up” content is bad. In creative writing, ideation, and exploratory design, inventing details is the point. The problem is when invented content is mistaken for factual content. A practical approach is to label modes explicitly:

• Factual mode: “Use only provided sources; otherwise say unknown.”
• Speculative mode: “Propose possibilities; label them as hypotheses.”
• Creative mode: “Invent freely; no need for real-world accuracy.”

By naming the mode, you reduce the chance that speculative content is later reused as if it were verified fact.

Checklist: A Simple Anti-Hallucination Protocol for Everyday Use

• State the goal: accuracy vs creativity.
• Provide grounding text or ask the model to request it.
• Require clarifying questions instead of guessing.
• Ask for evidence-first bullets before conclusions.
• Constrain length and scope to reduce extra claims.
• Self-critique: ask the model to flag uncertain claims.
• Verify high-risk details externally before using.