How Language Models Fail: Token-Level Signatures of Committed and Persistent Reasoning Failures | Tanvi Thoria et al. | ResearchPod

Transcript: How Language Models Fail: Token-Level Signatures of Committed and Persistent Reasoning Failures

Alex: Welcome to another episode of ResearchPod. Today, we're looking at how large language models—those complex AI systems that generate text—actually stumble when they're trying to solve problems.

Sam: We're discussing a paper that challenges how we think about AI errors. Usually, we treat a wrong answer as a simple pass-or-fail event. But this research suggests that reasoning failures have distinct patterns—almost like signatures—that reveal whether a model is stubbornly locked into a mistake, or just genuinely lost.

Alex: So the paper is asking whether we can look at the *way* a model fails to understand *why* it failed?

Sam: Exactly. The authors argue that treating all errors the same way is itself a mistake. They identify two specific failure patterns: one where the model commits to a wrong path very early on, and another where it stays confused and uncertain from beginning to end.

Alex: That reminds me of two very different kinds of students on a test. One confidently writes the wrong answer and never looks back. The other is clearly struggling the whole time—crossing things out, second-guessing every sentence.

Sam: That's a precise analogy, and it maps directly onto what the researchers found. To tell these two patterns apart, they track what's called "token-level uncertainty." Think of it as the model's internal confidence meter—not for the whole answer, but for every single word it writes, one at a time.

Alex: And this confidence meter is based on the numerical scores the model assigns to each word as it goes?

Sam: Yes. These scores—technically called log probabilities—show how sure the model is about each word choice. By watching how those scores rise or fall as the model works through its reasoning, you can see whether its confidence is building or collapsing.

Alex: And you don't need to look inside the model to do this? You just need the output it produces?

Sam: That's the key practical point. You only need the text itself and the confidence scores attached to each word. That matters a great deal, because many of the most powerful AI systems are what researchers call "closed"—meaning we have no access to their internal settings or structure. This method works from the outside.

Alex: So walk me through the first failure type. If a model is "committed" to a wrong answer, what does that actually look like in the confidence scores?

Sam: In a committed failure, the model latches onto an incorrect path very early—sometimes in the first few sentences of its reasoning. And here's the part that's easy to miss: its confidence meter doesn't drop. It stays high, or even rises. The model isn't second-guessing itself. It's convinced it's on the right track, even though it's heading in the wrong direction. The researchers call the moment this lock-in happens the "commitment point."

How Language Models Fail: Token-Level Signatures of Committed and Persistent Reasoning Failures

Tanvi Thoria, Kiana Jafari, Marc R. Schlichting, Mykel J. Kochenderfer

Jun 4, 2026·5:12·arxiv·Original Paper

Committed FailurePersistent UncertaintyToken-Level Uncertainty SignalsSelf-ConsistencyToken-level uncertaintyCommitment point

Listen

5 min

Briefing

This paper investigates how language models (LLMs) fail during complex reasoning tasks. Rather than treating failure as a binary outcome, the authors propose that reasoning failures follow distinct, identifiable processes that leave specific "signatures" in the model's token-level uncertainty signals.

Research Approach

The authors analyze chain-of-thought (CoT) reasoning traces using only the log probabilities of generated tokens. By calculating uncertainty metrics—such as entropy, margin, and negative log-likelihood—across different "prefix windows" (segments of the reasoning trace), they track how uncertainty evolves. They specifically control for the "length confound," where longer traces might otherwise skew results, by stripping tokens that occur after the final answer is provided.

Two Modes of Failure

The framework identifies two empirically distinguishable failure modes:

Committed Failure: The model locks onto an incorrect reasoning path early in the process. A key diagnostic is the "commitment point"—a specific position in the trace where uncertainty signals are most predictive of failure. Beyond this point, additional tokens provide no further diagnostic value and may even obscure the failure signal.
Persistent Uncertainty: The model does not lock onto a single path; instead, uncertainty accumulates monotonically throughout the entire reasoning trace. In this mode, the full trace is required to distinguish between successful and failing completions.

The authors validated this framework across 23 different model-dataset configurations, including frontier models like GPT-4o and Gemini 2.5 Pro, finding that their predictions held in 20 of the 23 cases.

Why It Matters

This research provides a foundation for more intelligent failure detection. Current methods, such as self-consistency (sampling multiple times to see if the model agrees with itself), are often ineffective for "committed failures" because the model consistently reproduces the same incorrect answer. By identifying the failure mode, developers can determine when to rely on self-consistency and when to use single-completion uncertainty signals instead. This allows for more efficient and accurate monitoring of LLM reliability without needing access to internal model weights.

Key Terms and Definitions

Committed Failure — A failure mode where the model settles on an incorrect reasoning path early in the generation, making the early part of the trace the most diagnostic.
Persistent Uncertainty — A failure mode where the model remains uncertain throughout the reasoning process, requiring the full trace to accurately detect the failure.
Commitment Point — The specific token position in a reasoning trace where uncertainty signals reach their maximum predictive power regarding the final outcome.
Self-Consistency — A verification strategy that samples multiple reasoning chains and uses the majority-vote answer to determine the final output.
Pre-final Analysis — A technique that removes tokens appearing after the final answer marker to ensure that trace length does not artificially inflate uncertainty metrics.
PR-AUC — The area under the precision-recall curve, used here as the primary metric to evaluate how well uncertainty signals can classify model failures.

Abstract

Failures in language model reasoning emerge through distinct processes that leave identifiable signatures in the reasoning trace. We characterize these failures using token-level uncertainty signals, finding they arise through two empirically distinguishable processes. The first is committed failure, in which a model locks onto an incorrect reasoning path early in its trace. A central diagnostic signature is the commitment point, beyond which considering additional tokens hurt rather than help failure detection. In the second, persistent uncertainty, uncertainty instead accumulates throughout, and the full trace is needed to best distinguish failing from successful completions. These signatures reproduce across 23 model-dataset configurations, with the framework's falsifiable predictions holding in 20 of 23 cases, well above chance across both failure modes. Finally, we demonstrate our failure mode framework has direct implications for self-consistency, identifying when uncertainty signals complement it and when it can be selectively skipped. These results offer a foundation for understanding when LLM reasoning failures become detectable and for adapting detection strategies accordingly.

How Language Models Fail: Token-Level Signatures of Committed and Persistent Reasoning Failures: Research Paper Podcast