When language models fail in production, they rarely fail randomly. They fail in a few predictable modes. Knowing these modes is like having a diagnostic checklist: you know exactly where to look and how to build your evaluations. Letβs go through the most important ones.
Comprehension: the model doesnβt understand the input
A failure of comprehension occurs when a model misses details stated in the prompt or loses the thread in long, multi-step contexts. The primary symptom is a response that answers a question you never asked. You catch this by evaluating the model against dense, high-token inputs.
Reasoning: brittle logic
A failure of reasoning happens when the model settles for surface-level patterns, slipping on multi-step inference and novel logical chains. You expose this by benchmarking against genuinely new problems, rather than standard datasets the model likely memorised during training.
Structured generation: the format breaks
Breaking on structured output happens when the model produces invalid JSON, invents a schema field, or returns a value outside an allowed list. This is the easiest mode to detect β a downstream schema validator simply catches and logs the broken output.
Fidelity: hallucination
A failure of fidelity β commonly called hallucination β is perhaps the most critical. The model ignores the provided context and invents information, cites a non-existent source, or backs down from a documented truth under pressure. This mode is dangerous because the output is structurally plausible. You catch it by measuring responses against datasets with known, deterministic answers, testing how tightly the model remains anchored to its context.
Calibration: misplaced confidence
A failure of calibration has two faces. The first is overconfidence: the model is certain about everything and refuses to say βI donβt know.β The second is sycophancy: under user pressure, the model abandons its own correct reasoning to agree with a flawed premise. Both are measured via adversarial tests that deliberately invite the model to err, observing whether it holds firm or yields.
Instruction-following: rules get ignored
A failure of instruction-following occurs when the model violates multi-part rules, drops a constraint, or ignores negations. A critical sub-case is prompt injection: the model executes instructions hidden inside the userβs input rather than adhering to the system prompt. You expose this using strict constraint-satisfaction tests and adversarial inputs.
Initiative: it answers only what was asked
A lack of initiative means the model answers exactly what was explicitly asked, failing to flag obvious gaps or missing context. This behaviour is acceptable for closed tasks but brittle for open-ended workflows. You test for this by assigning ambiguous tasks and observing whether the model goes beyond the bare minimum.
From a list of failures to a list of tests
Because these failure modes are predictable, you can build a specific test for each. Instead of waiting for users to discover failures in production, turn this taxonomy into a continuous evaluation checklist. Measure every candidate model against it. This is the difference between a system that understands its own boundaries and one that is surprised by every new edge case.