A hospital system observed a strong correlation between shorter ER wait times and higher patient satisfaction. Real, consistent, statistically significant across multiple facilities. An analyst fed three years of records into an LLM and asked what should we do about this? The model confidently identified the pattern and recommended reducing wait times. The hospital hired additional intake staff, cut median wait times by 22 minutes at a cost of $2.3 million, and patient satisfaction didn't move. The model had answered the question it could answer—what the data shows—not the question the analyst needed: what happens if we intervene? The difference isn't statistical. It's structural. The real causal story involved staffing levels as a common cause of both wait times and satisfaction, creating a back-door path. The model had no way to see this. It had patterns, not causal structure.

The analyst needed P(Satisfaction | do(WaitTime=low))—the effect of intervening on wait times, severing that variable from everything that naturally causes it. The model answered P(Satisfaction | WaitTime=low)—the satisfaction observed when wait times happen to be short in the existing system. These look like the same question to someone working without causal vocabulary. They are not. The first is a causal quantity asking what happens under an intervention. The second is purely observational. The difference is not about getting a better estimate. It's a structural gap in the system. When you observe short wait times naturally, you're also observing whatever caused those short times. When you intervene, you cut those causal links. This distinction separates causal inference from pattern-matching, and it's exactly what next-token prediction struggles with.

Judea Pearl's Ladder of Causation is the organizing framework for understanding what a causal question is asking. Rung 1 is association—purely observational questions about patterns in data: what does the data show? LLMs often answer these well because they are pattern-matching problems. Rung 2 is intervention—causal questions about do-operators: what happens if we change X? These require understanding structural causal models and breaking observational associations. Rung 3 is counterfactual reasoning: would this specific person have gotten sick if they hadn't taken the drug? The rungs build: Rung 3 requires everything Rung 2 requires, plus the ability to reason backward through time using individual-level potential outcomes. Most practical causal questions live on Rung 2. And most LLM failures on causal questions happen at Rung 2 or above.

This is an architectural problem, not a data quantity problem. Next-token prediction trains on observational data and learns to continue sequences based on statistical patterns. The model learns P(token | prior tokens). This is inherently an observational task. The training objective—predict what comes next given what came before—makes no distinction between correlation and causation. A model could see the pattern staffing levels predict wait times, wait times predict satisfaction and learn to reproduce that perfectly. But reproducing an observational pattern is not the same as understanding its causal structure. The model has no built-in way to reason about interventions, to imagine what would happen if you severed a causal link. It has no mechanism for representing the distinction between seeing a pattern and breaking a link. Scaling up data or model size doesn't fix this. The problem isn't that the model lacks information about causation. It's that the training task itself doesn't require or reward causal structure.

In the hospital case, the LLM identified a real pattern: facilities with shorter wait times reported higher satisfaction. The model learned this association and could describe it fluently. But a causal graph would have revealed the backdoor path. If you draw the DAG—WaitTime ← StaffingLevel → Satisfaction—you immediately see that conditioning on WaitTime while StaffingLevel is uncontrolled leaves a confounding path open. The model had no such graph. It had statistical associations: WaitTime predicts Satisfaction, so changing WaitTime should change Satisfaction. These are qualitatively different objects. A pattern is a regularity in observed data. A causal graph is a representation of mechanisms—how variables relate through intervention, not just through observation. LLMs learn the former; causal reasoning requires the latter. You can have perfect pattern-matching and complete causal blindness simultaneously. This is not a flaw in training data or architecture. It's what the architecture is built to do.

The hospital case contains a specific mechanism: staffing levels serve as a common cause for both wait times and satisfaction. This creates what Pearl calls a backdoor path: WaitTime ← StaffingLevel → Satisfaction. A backdoor path is an association that flows backward, not forward along causal arrows. It's confounding. When staffing is high, wait times are low and satisfaction is high—not because low wait times cause high satisfaction, but because staffing causes both. The observational correlation P(Satisfaction | WaitTime = low) is real. But it's generated entirely by the backdoor path. If you intervene on wait times without controlling staffing, you break the forward causal link but the backdoor path remains open. Satisfaction won't change because staffing, not wait time, does the causal work. This is why the intervention failed. The model could not see this path because it had no representation of causal structure. It saw only the association, which was real and strong.

You will be able to predict the specific failure mode an LLM exhibits on a causal question. There are three. First: confident wrong answer. The model identifies a pattern, applies standard reasoning, and produces a plausible-sounding but false causal claim. The hospital case is this failure mode—the model confidently recommended intervening on wait times because it saw a real association and applied the heuristic: strong correlation, actionable variable, recommend intervention. Second: fabricated mechanism. The model, sensing that an explanation is expected, generates a causal story that sounds coherent but isn't grounded in structural reasoning. It invents mechanisms rather than discovering them. Third: correct hedge. The model says something like correlation doesn't imply causation, more data needed. This hedge is often right as a practical matter, but it obscures whether the model is reasoning cautiously or simply outputting a memorized phrase. These three modes are not equally common, and not equally dangerous.

You can diagnose whether a model's correct-sounding hedge reflects genuine structural reasoning or trained hedging behavior using prompt sensitivity. If a model is truly reasoning about causation, its outputs should respond to changes in the causal structure you describe. If you add a confounder to the scenario, a reasoning model should flag new ambiguity or change its recommendation. If you block a causal path, it should reconsider. If the model's behavior doesn't change—if it outputs the same hedge regardless of structural changes, or confidently recommends the same action despite new confounders—then it's not reasoning about structure. It's pattern-matching or outputting a memorized response. Genuine causal reasoning is sensitive to causal structure. Trained hedging is not. This is your diagnostic instrument. It's not foolproof—a model could learn to fake sensitivity by pattern-matching on keywords—but it's far better than assuming that a cautious-sounding statement implies actual causal reasoning.

The practical implication of understanding LLM causal limitations is learning how to route. Not all causal-sounding questions are the same. A Rung 1 question—what's the association?—LLMs often answer well. They can tell you what patterns exist in data. A Rung 2 question—what if we intervene?—requires either structural causal reasoning, which LLMs lack, or explicit causal inference tools. A Rung 3 question—what would have happened?—is even harder. A routing architecture assigns each query to the appropriate tool. If a user asks a Rung 1 question, route to the LLM or pattern-analysis tool. If they ask Rung 2 or 3, route to a causal inference framework that accepts a user-specified DAG, or route to a human who can help specify one. This is not because LLMs are useless for causal reasoning. It's because knowing their specific failure modes lets you use them safely within their bounds and supplement them with the right tools at the boundaries.

These concepts connect around a central practical insight: LLM failures on causal questions are not random, and they're not invisible if you know what to look for. You now have the vocabulary to classify any causal question quickly—before an LLM gets a chance to mislead you. You know why next-token prediction cannot produce structural causal reasoning; this is architectural, which means no amount of data or scale will fix it. You can predict what failure mode an LLM will exhibit on a given causal question: confident wrong answer because it applied pattern-matching to a structural problem, fabricated mechanism because it generated a coherent-sounding story, or correct hedge that may or may not reflect real reasoning. You have a diagnostic tool—prompt sensitivity—to distinguish genuine causal reasoning from trained hedging. And you understand how to design a routing architecture that puts LLMs to work on problems they can solve while steering harder causal questions to tools that can handle structure. The problem this chapter opened with was expensive. Understanding it makes future mistakes cheaper and avoidable.

Three connected claims thread through this chapter, and they're worth stating together. First: the difference between association and intervention is structural, not statistical. You cannot estimate your way from observational patterns to causal claims without addressing that structure. Second: next-token prediction, by its nature, cannot capture this structure. It learns patterns in observational data and has no built-in objective to distinguish causation from correlation. Scaling the model makes this worse, not better—you get more fluent wrong answers. Third: this failure is not incidental to how LLMs work. It's central to what they do. Once you understand this, the failures stop looking like bugs and start looking like features—specific, predictable, and avoidable through proper routing and tool design. The LLM in the hospital case wasn't broken. It was doing exactly what it was trained to do: find patterns and extrapolate. It was just asked a question that required something different.