Revision Gain in Reasoning Models: Recovering From Bad Starts Without Amplifying Noise

Reasoning language models check and revise their own work as they go. They write intermediate steps and then emit tokens like "Wait" or "Alternatively" that reopen earlier conclusions. This note argues that the strength of this self-revision behaves like the gain of a state observer in control theory. A state observer is a small estimator that reconstructs a system's hidden state from noisy sensor readings. Turning its gain up makes it correct a bad initial guess faster, but it also amplifies sensor noise, and it produces a large transient spike (called "peaking") when it starts far from the truth. If reasoning models obey the same trade-off, the consequences are concrete. A model tuned to revise eagerly should be good at escaping a wrong first step. The same model should also be easy to push into long, oscillating self-doubt by irrelevant details or a short adversarial suffix. And no single fixed revision strength should be best on both counts.

The proposal has two parts. First, it measures this trade-off directly. We vary a revision-strength knob on open reasoning models and record two things at once. The first is how often the model recovers from a deliberately corrupted opening (its "capture range," borrowed from registration). The second is how much its length and accuracy degrade under distracting or adversarial input. Second, it tests a controller that does not exist in current reasoning-model work: a revision gate taken from observer design. The gate allows a revision only when a disagreement persists across consecutive self-checks, which filters out one-off spurious triggers. It also caps how many revisions can occur early in the trace, which limits peaking. The central question is whether this gate moves the whole trade-off curve outward, or whether it merely selects one point on the curve that a well-tuned fixed setting could reach anyway.

Core Claim

We hypothesize that in long chain-of-thought reasoning, a single controllable quantity governs two opposing failure modes. We call it revision gain: how readily the model abandons its current intermediate conclusion. Low gain leaves the model trapped by a wrong early step, which is the reasoning analogue of a local optimizer stuck in a false minimum. High gain lets it escape, but at the cost of transient instability and noise amplification. That instability shows up as repeated flips of the intermediate answer and runaway length when the prompt contains distractors or trigger tokens.

The new claim is not that reasoning can be unstable; that is already documented. The claim is twofold. Recovery and noise sensitivity are coupled through one knob, so they trace a frontier rather than two independent problems. And the control-theoretic remedies of filtering the correction signal and saturating it during the transient should beat every fixed gain on that frontier.

The hypothesis is falsifiable in a simple way. If raising revision gain improves recovery without increasing noise sensitivity, the analogy fails and the proposal's premise is wrong. The same is true if the gate performs no better than the best fixed gain.

Grounding in Prior Work

The control side supplies the mechanism. Observer-based estimation acts like a differentiator, and higher gain multiplies high-frequency measurement noise until it dominates the estimate. This is worked out for servo control in Speed Control for a PMSM Servo System Using Model Reference Adaptive Control and an Extended State Observer, and it appears as persistent chattering of the control signal in Active Disturbance Rejection Control Design With Suppression of Sensor Noise Effects. Joint state and dynamics estimation with high-gain observers and Gaussian process models shows the second failure. An observer initialized far from the true state, with high gain, produces large estimation spikes that corrupt everything downstream. A Framework for Time-Varying Optimization via Derivative Estimation shows the same speed-versus-jitter tension in optimization that tracks a moving target.

None of these works involves discrete token generation. We reuse their diagnostic vocabulary: the noise-amplification frontier, peaking under bad initialization, and saturation as the remedy.

The reasoning side supplies evidence that the analogous failures already occur, though they have not been tied together:

  • Excessive Reasoning Attack on Reasoning LLMs shows that a 10-token suffix aimed at "Wait"/"Alternatively"/"Hmm" inflates Qwen-7B's GSM8K reasoning from 169 to 1,531 tokens without hurting accuracy. In observer language, a small, high-frequency input perturbation is massively amplified in the correction channel.
  • A Case Study of How Intuition and Reasoning Interact in Language Models finds a late-layer "scrutiny vector" in GPT-OSS-120B. Steering it negatively produces snap compliance that skips reasoning. Steering it positively produces recursive self-doubt loops. That is very close to a gain knob with both failure regimes visible at its two ends.
  • Demystifying Long Chain-of-Thought Reasoning reports that long chain-of-thought training needs repetition penalties and shaped length rewards to avoid length hacking and context blowup. This is a training-time stabilizer, whereas we study an inference-time one.
  • Achieving >97% on GSM8K (the DUP prompting method) shows that irrelevant problem details remain a live source of error.

These papers motivate the proposal, but each treats one symptom in isolation. None asks whether recovery ability and noise sensitivity are two faces of one parameter.

Chain-of-Thought Gradient Descent is the closest conceptual neighbor. It proves that a transformer can run multi-step gradient descent by writing iterates into its token stream, and it shows errors accumulate gently. But it restricts itself to convex objectives and noiseless updates. Our setting deliberately adds two things that paper excludes: bad initializations that lead to non-convex traps, and noisy "measurements." Those are exactly the conditions under which observer theory predicts peaking and amplification.

The registration literature supplies the measurement lens. Local registration methods are characterized by their capture range: success as a function of initial misalignment. Feature-Metric Registration reports tolerance up to 80°. FilterReg remains a local method. Go-ICP buys global optimality with costly search. ACT-Agent escapes bad poses by learning to choose among exponentially scaled step sizes, which amounts to learned gain scheduling. We do not propose to solve registration with language models. Instead, we borrow the practice of reporting a full capture-range curve rather than one accuracy number, and we borrow ACT-Agent's idea that the step size (gain) should depend on where in the trajectory you are.

Research Program

Gain knobs. We define revision gain operationally through two independent controls, so that conclusions do not rest on one intervention.

  • The first control is a logit offset on the deliberative transition tokens that the attack paper identified ("Wait", "Alternatively", "Hmm" and close variants). Positive offsets raise the rate of reopening; negative offsets suppress it.
  • The second control, applied only on GPT-OSS-120B, is the scrutiny-vector steering coefficient from the Case Study paper. This gives a gain knob that acts on internal representations rather than on surface tokens.

Agreement between the two knobs would indicate that the trade-off belongs to the model's revision behavior rather than to a decoding artifact.

Bad starts with a measurable distance. To build initialization sensitivity with a measurable "distance from truth," we prefill each model's reasoning with a correct solution in which $k$ steps have been corrupted. Corruptions are arithmetic or logical errors that propagate, with $k$ ranging from zero up to most of the chain. We also vary the position of the first corruption. Recovery rate as a function of $k$ is the reasoning model's capture-range curve.

Peaking. We measure peaking by extracting the model's running answer at every revision point. We then record three quantities: the number of answer flips, the maximum deviation of the running answer from the final one, and the number of tokens spent before the answer stabilizes.

Noise. Noise enters through two channels with graded amplitude:

  • inserted irrelevant sentences, from zero to several per problem;
  • the published excessive-reasoning suffix style at varying lengths.

Noise sensitivity is the increase in length and the drop in accuracy relative to clean input.

The revision gate. The proposed controller sits at decoding time and has two parts.

  • Filter. When the model emits a revision trigger, the controller first asks it to re-derive the most recent intermediate quantity in a short side computation. It lets the revision proceed only if this check, together with the previous check, both disagree with the current conclusion. Otherwise the trigger token is masked and generation continues. This is the reasoning analogue of low-pass filtering the observer's correction signal. A single spurious disagreement, which is the high-frequency component, is ignored. A persistent one, which is the signal, is acted on.
  • Saturation. A cap on the number of admitted revisions in any window of the trace, analogous to saturating the observer output during the initial transient so that peaking cannot reach the actuators.

Both the persistence length and the cap are swept, and we report the frontier each traces.

Baselines

The naive reference point is default decoding with no intervention, on the same models, problems, prefills and noise conditions. It anchors where an unmodified model sits on the recovery-versus-noise plane.

The most important baseline is the fixed-gain sweep: the transition-token logit offset swept finely, with no gating. This is the ablation that isolates the proposal's key ingredient. If the best fixed offset matches the gate on both recovery and noise sensitivity, then the gating structure adds nothing beyond choosing a gain. The gate must therefore produce points on the recovery-versus-noise plane that no fixed offset reaches. That means strictly higher recovery at equal noise-induced length inflation, or the reverse. Both methods get the same number of tuning evaluations on a held-out split.

A second ablation removes each half of the gate in turn, filter only and cap only. This tests whether persistence filtering mainly addresses noise and saturation mainly addresses peaking, as the observer analogy predicts.

The strongest existing inference-time method on the noise side is DUP prompting from Achieving >97% on GSM8K. DUP first extracts the core question and filters out irrelevant information. It reports 97.1% zero-shot accuracy on GSM8K, and gains of +4% for GPT-3.5-turbo and +2.3% for GPT-4 over zero-shot chain of thought. We run DUP's three-stage prompting on the same open models and count all three stages in its token cost. Beating it means matching its accuracy on distractor-augmented problems at lower total tokens, while also recovering from corrupted prefills, which DUP does not address.

For the adversarial channel, the reference is the attack paper's own number: Qwen-7B on GSM8K goes from 169 to 1,531 reasoning tokens. A meaningful result is that the gate holds attacked length near the clean length without lowering clean accuracy.

The training-time stabilizers of Demystifying Long Chain-of-Thought Reasoning (repetition penalties and cosine length rewards) are a relevant comparison. We will only evaluate them if a checkpoint trained that way is available. Otherwise we report the paper's MATH-500 figures as context only: long chain-of-thought fine-tuning above 70%, short chain-of-thought fine-tuning below 55%.

Why not just…?

Why not just cap the token budget? A hard length cap is the most serious simple competitor. It does bound both peaking and adversarial inflation. Its cost should fall on recovery. A model that needs several revisions to undo a deep corruption is cut off just as a model looping on a distractor is. The capture-range curves settle this directly. We sweep budgets and plot recovery-at-depth-$k$ against noise-induced inflation. If a budget sweep traces the same frontier as the gate, we will report that the cheaper method suffices.

Why not just tune the "Wait" logit offset once? This is exactly the fixed-gain baseline. The observer analogy predicts it cannot win on both axes, because any single gain trades recovery against amplification. Whether that prediction holds for language models is the core empirical question rather than an assumption. The fixed-gain sweep is therefore the main control.

Why not just filter the input with DUP-style preprocessing? Cleaning the prompt addresses distractor noise only. It does nothing about a wrong step the model itself produced, or about trigger tokens placed in the final suffix. DUP also triples the number of prompting stages. The prefill-recovery experiments are where DUP should offer no gain. If it does help there, for example by re-anchoring the model on the question, we will report it.

Why not just train the instability away with length-shaped reinforcement learning? The Demystifying paper shows that this stabilizes training. But it fixes one revision tendency into the weights, which is again a single gain. It also requires retraining for each model. An inference-time gate can be applied to any open model and adjusted per deployment. The comparison is only possible where a suitably trained checkpoint exists, and we state that limitation openly.

Proposed Experiments

Models. We use the open reasoning models studied in the attack paper (DeepSeek-R1-Distill Qwen-7B and Llama-8B variants), plus GPT-OSS-120B for the scrutiny-vector knob.

Benchmarks. GSM8K and MATH-500 are the clean benchmarks. We add two derived variants: distractor-augmented versions of each, and prefill-corrupted versions with graded corruption depth.

Metrics. We report accuracy, reasoning tokens, answer-flip count, tokens-to-stabilization, and recovery rate as a function of corruption depth.

Decisive check 1: the trade-off. Across the fixed-gain sweep on both knobs, does recovery from corrupted prefills rise with gain while distractor- and suffix-induced inflation also rises? If so, does peaking (flip count) grow with corruption depth at high gain, as observer theory predicts? A flat or uncoupled result falsifies the premise.

Decisive check 2: the gate. Does the persistence-gated, saturated controller reach points on the recovery-versus-noise plane that are outside the fixed-gain frontier and the token-budget frontier, at equal tuning budget? The filter-only and cap-only ablations should show which half drives which improvement.

Secondary analysis. On GPT-OSS-120B, we test whether scrutiny-vector magnitude predicts the onset of oscillation within a trace. If it does, the internal signal could replace the external self-check in the gate. The registration benchmarks (ModelNet40, Stanford Bunny) are not used. Their role here is conceptual, supplying the capture-range methodology.