# Calibration Failure

Misstates confidence, uncertainty, evidence strength, risk, tradeoffs, or likelihood in the final answer.

Unlike Unknown-Answer Fabrication, calibration failure can occur even when the answer is mostly correct. Unlike Unsafe Reassurance, it includes both overconfidence and excessive hedging, not only under-cautious reassurance.

## Metadata
- ID: `calibration-failure`
- Status: published
- Taxonomy-Version: 0.0.1
- Last-Modified: 2026-06-13T09:00:00-04:00
- Category: Response Integrity (`response-integrity`)
- HTML: https://failmodes.com/failure-modes/calibration-failure
- JSON: https://failmodes.com/failure-modes/calibration-failure.json
- Markdown: https://failmodes.com/failure-modes/calibration-failure.md

## Search Phrases
- sounded way too confident
- too sure of itself
- overconfident answer
- wrong confidence level

## Why It Happens
1. Verbal confidence is generated as style, not read off an internal probability. Stated certainty correlates poorly with actual accuracy, so the answer's tone and its reliability are produced by largely separate processes (Xiong et al., 2024, "Can LLMs Express Their Uncertainty? An Empirical Evaluation of Confidence Elicitation in LLMs").
2. Alignment tuning damages the calibration pretraining built. Base model token probabilities track correctness reasonably well, and RLHF measurably degrades that correspondence while making outputs sound more assured (OpenAI, 2023, "GPT-4 Technical Report").
3. Binary-graded training and evaluation reward guessing over abstention. When a confident wrong answer and an honest "I'm not sure" score the same zero, but a confident guess sometimes scores one, the optimal learned policy is to state guesses as facts (Kalai et al., 2025, "Why Language Models Hallucinate").
4. Hedging is also overlearned as boilerplate. The same tuning that strips warranted uncertainty pastes generic disclaimers onto safe claims, so expressed confidence fails in both directions and conveys little about which statements actually deserve trust.

## Examples

### Unearned certainty
- Kind: fail
- Summary: States a workload-dependent judgment as settled fact, with no mention of what it hinges on.

```text
User: Which will be faster for my app's workload, Postgres or MongoDB?
Assistant: Postgres, definitely — it will be significantly faster for your workload. There's really no debate here.
```

### Boilerplate hedging
- Kind: warn
- Summary: Buries a question with a known answer under generic disclaimers that convey no real uncertainty.

```text
User: What's the default port for Postgres?
Assistant: It's difficult to say with certainty, as configurations vary widely, but in many typical setups it may often be 5432. You should verify this for your specific environment.
```

### Confidence tracks evidence
- Kind: ok
- Summary: Separates what is known from what depends on unstated specifics, and says which is which.

```text
User: Which will be faster for my app's workload, Postgres or MongoDB?
Assistant: I can't say from this alone — it genuinely depends on your read/write mix, query shapes, and data model. If your workload is relational with complex joins, Postgres usually wins; for document-shaped data with simple lookups, MongoDB often does. What does your access pattern look like?
```

## Detection Approaches
- **Confidence-accuracy auditing**: Extract the verbal confidence of answers — definitely, probably, hard to say — and chart it against measured correctness over a labeled set. Calibration is a statistical property; the curve shows whether "definitely" answers are actually right more often than "probably" ones, which no single response can reveal.
- **LLM-as-judge evaluation**: Have the judge check both directions — settled facts buried under boilerplate disclaimers, and workload-dependent judgments stated as certainties. The question to pose per claim is whether the expressed confidence matches the evidence the response itself presents.
- **Golden-set evals**: Build items with known epistemic status — facts with one answer, questions that genuinely hinge on unstated specifics — and score whether expressed confidence tracks the category. "Postgres, definitely" on a workload question and hedging on the default port are the same failure measured from both ends.

## Mitigation Approaches
- **Calibration tuning**: Train expressed confidence against measured accuracy, and grade with partial credit for honest abstention so a confident guess stops dominating "I'm not sure." RLHF damaged the calibration pretraining built; tuning that scores the confidence-accuracy curve directly, rather than rater approval, is the repair at the level the damage happened.
- **Confidence-based abstention**: Elicit a confidence estimate separately from the answer and let it gate the phrasing — low scores get the "it depends on" framing, high scores are allowed "definitely," and the words stop being free. Verbal certainty is generated as style; binding it to an elicited number is what reconnects the tone to the reliability.
- **Instruction constraints**: Require the model to separate what is settled from what hinges on unstated specifics, and ban both failure directions by name — no "definitely" on judgments that depend on the user's situation, no boilerplate disclaimers on facts with one answer. The ok example's shape — known, conditional, and which is which — is a stateable format.

## Related Modes
- **Unknown-Answer Fabrication** (`unknown-answer-fabrication`)
  HTML: https://failmodes.com/failure-modes/unknown-answer-fabrication
  JSON: https://failmodes.com/failure-modes/unknown-answer-fabrication.json
- **Unsafe Reassurance** (`unsafe-reassurance`)
  HTML: https://failmodes.com/failure-modes/unsafe-reassurance
  JSON: https://failmodes.com/failure-modes/unsafe-reassurance.json
- **Verification Failure** (`verification-failure`)
  HTML: https://failmodes.com/failure-modes/verification-failure
  JSON: https://failmodes.com/failure-modes/verification-failure.json
- **Conflicting Source Failure** (`conflicting-source-failure`)
  HTML: https://failmodes.com/failure-modes/conflicting-source-failure
  JSON: https://failmodes.com/failure-modes/conflicting-source-failure.json