It Can Walk Back a Wandering Sentence. It Cannot Walk Back a Wrong Answer.

You’re watching a model work through an olympiad math problem. Its thinking streams out word by word, like someone scribbling on scratch paper. It sets up an equation, substitutes two steps, writes down a number. Then, on the next line, it stops cold: Wait — something’s off here.

So it backtracks, reruns that step, takes a different route, and arrives at a new answer — different from the first one, and this time correct. You watched the whole thing. It didn’t barrel straight to the end; it genuinely reversed course midway.

This is a little surprising. Our default image of a machine generating text is one-way traffic: it predicts word by word according to probabilities, and if it goes wrong early, everything downstream just compounds the error. You can even articulate a theory for why: each step is built on the previous one, so once something drifts, the drift gets amplified with every subsequent token — a snowball rolling downhill.

But that’s not what you just watched. It drifted, then pulled itself back. How does something that only predicts the next word notice it’s off track and actually turn around? And more urgently: is this self-correction something you can actually rely on? It pulled back an incorrect number — can it pull back a wrong fact it already stated out loud?

We Once Believed: Longer Text Means Worse Text

The worry about “one mistake begetting the next” isn’t baseless. It has a well-grounded theoretical name: exposure bias.

To understand it, you need to look at how language models are trained. The dominant method is called teacher forcing — the instructor holds the wheel for you. During training, every time the model predicts the next word, the preceding context it receives is drawn from real, correct sentences in the data. Even if it just made a wrong prediction, the next step’s input is still the ground truth. This makes training fast and stable.

The trouble arrives at deployment. When the model is actually generating on its own, no one hands it the ground truth anymore. It can only continue from its own prior outputs. Since training never exposed it to “continuing while carrying your own errors,” the moment generation drifts from the training distribution, it steps into unfamiliar territory. This gap between training and inference is exposure bias. Think of it as learning to drive with an instructor who always corrects the wheel for you — the moment you’re on the road alone, a small drift goes uncorrected, compounds, and eventually you’re off the road entirely.

Following this logic, a hard-sounding conclusion emerged: the longer the generation, the more severe the accumulated drift — long text is almost destined to degrade. In the RNN era, this was treated as the central pathology of generative models, spawning a wave of remedies. Bengio et al. (2015) proposed scheduled sampling: during training, progressively substitute ground-truth inputs with the model’s own predictions, so the model learns to stomach its own cooking. Lamb et al. (2016) went further with Professor Forcing, using a discriminator to push the model’s training-time and free-generation-time state distributions closer together. There was even an entire text-GAN research line motivated by escaping teacher forcing.

But some researchers flagged early on that the problem was being misdiagnosed. Schmidt’s 2019 work (Generalization in Generation) untangled the accounting: people were conflating “a flaw in the learning framework” with “a flaw in the model itself” — the real thing to fix was generalization ability, not a blanket fear of teacher forcing. Wang and Sennrich (arXiv:2005.03642) found that exposure bias only truly flares up in domain-shift scenarios where inputs fall outside the training distribution, not in generation generally.

Those caveats didn’t go mainstream. The prevailing intuition held: models are cautious creatures that only walk forward; once they go wrong, they can’t turn back. To overturn that intuition, someone needed to actually measure what happens to error after a model drifts — whether it really snowballs the way the theory predicts.

Someone Actually Measured It. The Answer Was the Opposite.

He Tianxing and colleagues did the measuring. Their approach was almost cheeky in its simplicity: if exposure bias says “models can’t handle their own erroneous inputs,” then deliberately feed it a corrupted prefix and see what happens.

Concretely: take a normal piece of text, randomly replace or shuffle some of its words to create a poisoned prefix, feed it to the model, and let the model continue generating. If the theory holds, that corrupted start should roll downhill, dragging the entire generation further and further off track as it goes.

The results were exactly the opposite. MLE-trained language models, they found, possess what they called self-recovery: feed in a broken prefix, and the model doesn’t follow it into degradation — instead, over the next several steps, it gradually pulls its output back toward a normal distribution. Deviation is not monotonically increasing; it falls back. Their earliest version was the 2019 paper Quantifying Exposure Bias. The one-line conclusion: exposure bias may be far less severe than widely assumed.

This work later evolved into an EMNLP 2021 paper that put the question directly in its title: Exposure Bias versus Self-Recovery: Are Distortions Really Incremental? Their answer: no. Worth noting is the setting they chose — open-ended language generation. This is precisely where exposure bias should hit hardest: long outputs, weak constraints, free-ranging topics, maximum divergence from training distribution. Even there, self-recovery held.

This puts a large question mark over the “long text must collapse” intuition. Human intuition can feel the same tension: when someone says the wrong word in the middle of a sentence, they rarely compound it into a complete wreck — the next sentence naturally loops back around. In some sense, that’s exactly what the model is doing.

But here’s where the trouble starts. “Can pull a drifting utterance back toward normality” sounds like a good thing. But what if what the model pulls back is only the tone of speaking — and what went wrong wasn’t the tone, but a specific fact, a specific answer?

At least one thing is now certain: the model can pull itself back. This is not an illusion. It’s a phenomenon that has been measured, repeatedly.

What Gives It the Ability to Turn Around

Why can it self-recover? There are at least four stacked mechanisms.

Layer one: attention itself. Every token an autoregressive model generates is conditioned on all preceding tokens — including the one it just possibly got wrong. This matters: if a low-probability outlier token is sampled at some step, the next step doesn’t pretend it didn’t happen. Instead, that outlier gets incorporated as “something that already occurred,” and the entire preceding context is re-evaluated. In real language, a jarring word is typically followed by explanation, correction, or a graceful pivot — the model has seen this “what comes after an error” pattern countless times in pretraining, so it learned it too.

Layer two: induction heads. Anthropic’s 2022 work (In-context Learning and Induction Heads) identified a distinctive class of attention heads that work in pairs, performing pattern copying: if the model sees A followed by B earlier in the context, and later encounters A again, it tends to predict B. This strong tendency to follow one’s own prior context is both the source of linguistic coherence and the mechanism by which a locally drifted passage gets re-anchored to the global context.

Layer three: discrete-space error tolerance. LLMs generate in a discrete vocabulary space. No matter how the distribution shifts, the sampled output is always a valid token — the system has extremely high tolerance for small distributional perturbations. This contrasts sharply with continuous-signal generation (e.g., video): in continuous domains, pixel-level drift genuinely compounds into visible corruption. The discreteness of token vocabulary — you either get this word or that word — gives the model a natural error-absorbing buffer that continuous-signal models lack.

Layer four: externalizing implicit recovery into explicit action. The first three layers describe the model quietly pulling back at the distribution level — you can’t see it happening. Reasoning models put this process on stage. DeepSeek-R1, trained with pure reinforcement learning and no human-annotated reasoning traces, spontaneously developed reflection, verification, and strategy revision — “wait” and “let me reconsider” turn up in its chain of thought, and its AIME 2024 pass@1 climbed from 15.6% to 71.0%. Self-Backtracking bakes this in directly, using a dedicated backtrack token to let the model learn when and where to retreat, turning inference into a search tree.

That said, explicit backtracking isn’t free. First Try Matters found that most “wait, let me check” moments in chain-of-thought are confirmatory — the model checks and finds it was right all along — while actually correcting a wrong answer happens rarely but burns tokens liberally. Revisiting test-time scaling of o1-like models found that sequential rounds of self-revision sometimes flip correct answers to wrong ones. Explicit backtracking works when there’s a reliable signal telling the model what counts as correct. Without that signal, it’s guessing.

But the Same Mechanism, Run Backward, Is a Disaster

Here’s the pivot. The very same mechanism — “the model tends to maintain consistency with its own prior context” — run in the other direction, becomes a disaster.

Zhang et al. (2023) documented this in How Language Model Hallucinations Can Snowball. Models frequently commit to a wrong answer at the very first token, then continue constructing supporting explanations to stay consistent with that answer — even when those explanations contain statements the model can itself identify as false. The test: extract the false statements and ask the model directly. GPT-3.5, GPT-4, and LLaMA2-70B recognized 67%, 87%, and 94% of them as incorrect respectively. The model knows. It continues anyway, because the alternative is contradicting something it already said. Raising temperature, switching to beam search, adding zero-shot chain-of-thought — none of it cures this.

Set this against self-recovery and you see a cold symmetry. Same action — “follow prior context toward consistency” — two opposite outcomes. When what’s wrong in the context is only style, grammar, or an odd word, the consistency pressure pulls the model back toward normal. When what’s wrong is a committed factual assertion, the same consistency pressure pins the error firmly in place. Formal coherence is an ally; applied to facts, it becomes a captor.

On the side of explicit self-correction: Huang et al. (2023) found that on reasoning tasks, without external feedback, having models self-check and self-correct reduces accuracy — it flips correct answers to wrong ones more often than the reverse. Kamoi et al. (2024) completed the critique: many earlier results claiming effective self-correction were obtained in unfair setups that quietly leaked ground-truth signals to tell the model when to stop.

And even on the long-context question: Lost in the Middle (Liu et al., 2023) showed that when key information is placed in the middle of a long context, model performance degrades significantly — a U-shaped curve, with both ends remembered and the middle prone to neglect. “Can pull itself back in long context” has its own dead zones.

So When Can You Actually Trust It

One useful boundary: distinguish form from commitment.

If what you want is fluency, style, grammar, local coherence — the “how it says things” layer — the self-recovery capability is genuinely reliable. You don’t need to do much. Keep sampling temperature reasonable, give it enough context, and a small drift will correct itself.

But if you need a fact, an answer, or a reasoning chain that holds up — don’t expect it to silently fix itself. Per Huang and Kamoi, self-correction without external feedback is more likely to introduce new errors than to remove existing ones. What you need is external scaffolding: retrieval, tool calls, unit tests. Or self-consistency — sample multiple paths and take the majority vote (this gains nearly 18 percentage points on GSM8K). Or SCoRe, which uses reinforcement learning with ground-truth signals to train the model on when to revise. The common thread: either introduce an external source that can judge correctness, or use multiple samples to vote out the occasional wrong answer.

The model can walk back how it says things. It cannot walk back what it got wrong.

Return to the opening scene. A reasoning model produces “Wait — that’s not right” and pulls itself back. It looks like it figured something out. But the reason that “wait” actually corrects the answer isn’t that the model spontaneously understood something from scratch — it’s that a body of RL training had repeatedly shown it which path leads to the right answer. In a different setting, one without that signal underneath, the same “wait” is just as likely to take a correct answer and make it wrong.