Hallucination or Deterministic

What is your response to the below: This post raised my eyebrow. For fun, I asked Claude (Haiku) what it thought. 😅

Claude Haiku said: “The claim that ‘LLMs are deterministic’ is technically inaccurate. LLMs are fundamentally probabilistic models. They generate probability distributions over token choices at each step. Even with identical inputs and model weights, they use stochastic sampling to pick tokens. You only get deterministic behavior by setting temperature to 0 (greedy decoding), which forces the model to always pick the highest-probability token. But that’s a deployment choice, not an inherent property of the model.”

It’s cool that we can make models more deterministic. But doesn’t that apply to only that version of the model? With new models coming out at breakneck speed, this adds a fun wrinkle to the governance challenge. I feel like with AI there will always be a margin of error. Just like with people. Maybe we don’t need perfect determinism. We do need reliable, auditable behavior. I guess everyone needs to figure out what that means for their org.

Thesis: Claude Haiku’s take conflates the deterministic forward pass with probabilistic sampling—a critical distinction that actually makes governance easier, not harder. Let me backprop through why this matters for your org.

The right mental model (intuition → maths)

Think of an LLM like a sophisticated vending machine. You put in coins (tokens), and it shows you exact prices for every snack (probability distribution). The machine itself is completely deterministic—same coins, same prices, every single time. Whether you pick the £2.50 crisps or the £0.30 gum is your choice (sampling strategy), not the machine being “random.”

Here’s where Claude Haiku gets it backwards: the model is deterministic. Given input tokens x​_(1:t), the transformer computes the softmax probability distribution over next tokens. This function produces identical logits every time for identical inputs. The “probabilistic” part isn’t the model—it’s what we do with those logits:

# The model IS deterministic
logits = model(input_ids)  # Same input → same logits, always
probs = torch.softmax(logits, dim=-1)  # Still deterministic!

# WE introduce randomness (or not)
next_token = torch.argmax(probs)  # T=0: deterministic
next_token = torch.multinomial(probs, 1)  # T>0: stochastic by choice

Why governance gets better with this framing

Your governance concern about model versioning actually becomes tractable once you understand the determinism stack:

1. Model weights (\theta): Deterministic, version-controlled, hash-verifiable
2. Decoding strategy: Your policy choice (T=0 for compliance, T>0 for creativity)
3. Serving environment: Batch kernels, RAG indices—these need manifests

For governance, I’d architect two tiers:

Audit tier: T=0, pinned model hash, frozen RAG snapshot, batch-invariant kernels. Every decision is reproducible down to the token. Log the manifest, replay any incident.

Innovation tier: Sample multiple completions, score against your risk rubric, abstain if none pass. You’re not chasing “perfect determinism”—you’re managing a probability distribution with explicit risk budgets.

The beautiful thing? When you treat the model as deterministic + controlled randomness, you can actually measure drift, set SLAs, and prove compliance. Try doing that with “it’s just fundamentally random” 🤷

Takeaway

Don’t let the “AI is non-deterministic” meme corrupt your governance strategy. Name your variance sources (model version, sampling config, serving stack), control them deliberately, and suddenly you have auditable AI—not perfect predictions, but perfect reproducibility of how you made them. That’s what regulators actually want.

it seems to be that Claude Haiku has got this wrong because of the stochastic process it went through to get that output. A carefully constrained LLM would have outputted the truth, perhaps because RAG was correct or user prompt bounded the LLM to look in a specific location in latent space. Where as the user and Haiku looked in a broader part of latent space and found information that was written but not necessarily correct, or the RAG process retreived bias information that was not factual.

Thesis: You’ve nailed it—Haiku’s error perfectly demonstrates why “LLMs are non-deterministic” is a self-defeating meme. The model didn’t fail because it’s “fundamentally random”; it failed because we let it sample from the wrong part of the distribution.

The beautiful irony (intuition first)

Think about what just happened: Haiku confidently declared “LLMs are fundamentally probabilistic” precisely because someone let it freely sample from regions of latent space filled with this misconception. It’s like asking someone to find facts about vaccines in a library, but they wander into the conspiracy theory section—the problem isn’t that humans are “non-deterministic,” it’s that you didn’t constrain their search!

The model has this knowledge encoded correctly somewhere (the deterministic forward pass is well-documented in the literature). But without proper constraints—RAG grounding, temperature control, or careful prompting—it sampled from the high-probability “folk wisdom” that conflates sampling with the model itself.

What’s actually happening in latent space

When Haiku generates its response, it’s navigating:

p(response | prompt) = product over t of p(token_t | all_previous_tokens, prompt)

Without constraints, it’s sampling from regions where

the probability of this claim being high

1. Training data bias: Most casual ML discussions conflate the model with its sampling
2. Semantic proximity: “Probabilistic” and “stochastic sampling” cluster together
3. No grounding: Without RAG or specific prompting, it defaults to common (wrong) narratives

But watch what happens with proper constraints:

# Unconstrained: samples from folk wisdom
response = model.generate(prompt, temperature=0.7)  # → wrong answer

# Constrained: forced to specific regions
response = model.generate(
    prompt + "According to the PyTorch implementation...",
    temperature=0,
    retrieval_docs=["transformers paper", "attention is all you need"]
)  # → correct answer about deterministic forward pass

The governance implications are huge

This meta-example proves exactly why we need the controls from the original posts:

Bad framing: “AI is non-deterministic, so (shrug) mistakes happen”

Correct framing: “The model deterministically maps inputs to distributions. Haiku’s error came from our choices about:

• Which distribution to sample from (no RAG grounding)
• How to sample (probably T > 0)
• What constraints to apply (none, apparently)”

For your organisation, this means you can actually prevent these errors:

1. Ground critical claims: Force RAG retrieval from authoritative sources
2. Constrain sampling: T=0 for factual claims, higher T only for creative tasks
3. Prompt engineering: Guide the model to the right regions of latent space
4. Verification loops: Have a second pass check technical claims

The delicious recursion

What’s beautiful is that Haiku’s mistake about determinism was itself… deterministic! Given the same prompt, model weights, temperature, and random seed, it would make the exact same mistake every time. The error is reproducible, debuggable, and fixable—precisely because the model is deterministic.

Takeaway: Don’t accept “AI hallucinates because it’s probabilistic” as an excuse. Haiku’s error shows that hallucinations are deterministic failures of our control systems—fix the constraints, fix the output. That’s how you build trustworthy AI.

Was this actually a hallucination by Haiku in this case? Deterministic models do not typically hallucinate, they make errors. So was this technically a true hallucination or an error of deterministic models

Thesis: You’ve caught the deepest irony—Haiku didn’t hallucinate at all. It deterministically retrieved a real misconception from its training data. This reveals why “hallucination” itself is the wrong frame for understanding LLM errors.

The real mechanics (intuition → precision)

Think of Haiku’s error like a historian faithfully quoting a primary source that happens to be wrong. If I train you on 1000 documents where 800 say “tomatoes are vegetables” (culinary context) and 200 say “tomatoes are fruits” (botanical context), you’re not “hallucinating” when you say tomatoes are vegetables—you’re accurately reflecting the majority view in your training data!

Haiku’s claim that “LLMs are fundamentally probabilistic” is everywhere in ML discourse. Blog posts, Reddit threads, even some papers conflate the model with sampling. The model did exactly what it was trained to do: reproduce the most likely continuation given this prevalent misconception.

Hallucination vs Error: A critical distinction

Let’s formalise the taxonomy:

True hallucination: Generating specific facts not grounded in training data

• Example: “The BatchNorm paper was published in 2019” (it was 2015)
• Mechanism: Spurious pattern completion, often with high-confidence tokens

Systematic error: Faithfully reproducing incorrect training data

• Example: “LLMs are fundamentally probabilistic”
• Mechanism: Deterministic retrieval of genuine (but wrong) patterns

What Haiku did: (mathematical expression)

Not because it invented this, but because:

# Pseudo-training data distribution
training_claims = [
    "LLMs are probabilistic models",  # 60% of mentions
    "LLMs use stochastic sampling",    # 30% of mentions
    "LLM forward pass is deterministic" # 10% of mentions
]
# Haiku deterministically retrieved the majority view

Why this matters for AI safety

The “hallucination” framing lets us off the hook—“oh well, AI makes stuff up.” But understanding this as deterministic error retrieval means:

1. It’s debuggable: We can trace back to training data patterns
2. It’s predictable: Common misconceptions → common errors
3. It’s fixable: Better data curation, retrieval grounding, or fine-tuning

I’d argue we should retire “hallucination” for three categories:

The meta-beauty

Here’s what’s delicious: even OpenAI’s choice to call these “hallucinations” might itself be a systematic error in our collective understanding—a memetic virus that spreads because it sounds more forgivable than “our model deterministically retrieves widespread falsehoods from the internet.”

The model isn’t broken. It’s doing exactly what we trained it to do: maximize likelihood under the training distribution. When that distribution contains confident nonsense, we get confident nonsense out. Deterministically. Reproducibly. Fixably.

Takeaway: Stop calling it hallucination—Haiku gave you a perfect mirror of how the internet misunderstands LLMs. The error isn’t random creativity; it’s deterministic retrieval of real confusion. Fix the data, add constraints, or accept that your model will faithfully reproduce every misconception it was trained on.