Why do some reasoning steps receive negligible attention from later steps?
This explores why later reasoning steps stop 'paying attention' to certain earlier ones — and what that reveals about which parts of a chain of thought actually do the work versus which are filler.
This explores why later reasoning steps stop 'paying attention' to certain earlier ones — and what the corpus says about which parts of a reasoning chain actually carry weight. The sharpest answer comes from work that read the attention maps directly: when a model categorizes its own reasoning into types — planning, deduction, verification, backtracking — the verification and backtracking steps turn out to receive almost no downstream attention. They're the model second-guessing itself, and the rest of the chain quietly ignores them. Strikingly, you can delete roughly 75% of reasoning steps by keeping only the high-attention ones and accuracy holds Can reasoning steps be dynamically pruned without losing accuracy?. So 'negligible attention' isn't a bug to fix — it's a signal that a step didn't contribute to the answer.
That reframes a lot of reasoning's known failure modes as attention problems in disguise. Models 'wander' down invalid paths and 'underthink' by abandoning promising ones prematurely — and the fix isn't more compute, it's discouraging the model from switching threads, which keeps it attending to a line of thought long enough to finish it Why do reasoning models abandon promising solution paths? Do reasoning models switch between ideas too frequently?. Each abandoned path becomes a stretch of low-attention tokens: written, then orphaned. The same dynamic shows up over distance — as chains get longer, the original instructions sit farther back and the model's attention to them dilutes, which is why more capable reasoners paradoxically follow instructions worse Why do better reasoning models ignore instructions? Why do more capable reasoning models ignore your instructions?. Attention is a budget, and length spends it.
There's a deeper, almost mechanical reason some steps get ignored: whether reasoning helps at all depends on whether the *question's* information actually flows into the prompt before reasoning starts. Saliency analysis shows that when question semantics don't aggregate into the prompt first, the step-by-step reasoning that follows is built on a weak foundation and later steps have little reason to attend back to it Why do some questions perform better without step-by-step reasoning?. Combine that with the finding that accuracy follows an inverted-U over length — peaking, then declining as models overthink easy problems — and a picture emerges: low-attention steps cluster in the over-generated tail, where the model is padding rather than computing Why does chain of thought accuracy eventually decline with length? Does more thinking time always improve reasoning accuracy?.
The twist worth taking away: if so many verbalized steps earn no attention, maybe the visible chain was never where the reasoning lived. A single steerable latent feature can trigger reasoning-mode performance with no chain-of-thought at all, and depth-recurrent architectures solve hard puzzles entirely in hidden computation — a 27M-parameter model nailing extreme Sudoku while text-based CoT scored zero Can we trigger reasoning without explicit chain-of-thought prompts? Can models reason without generating visible thinking steps?. This suggests the written steps are partly a transcript of computation happening elsewhere; the ones that get ignored are the parts that were never load-bearing to begin with. If you want the practical flip side — using *where* attention and errors actually fall to verify reasoning mid-trace rather than only scoring the final answer — that lifted task success from 32% to 87% Where do reasoning agents actually fail during long traces?.
Sources 11 notes
The PI framework categorizes reasoning into six types and uses attention maps to identify that verification and backtracking steps receive minimal downstream attention. Selecting only high-attention steps preserves accuracy while cutting reasoning length substantially.
Reasoning LLMs exhibit two reinforcing failures: wandering (invalid exploration) and underthinking (premature path-switching). Decoding-level interventions like thought-switching penalties improve accuracy without fine-tuning, suggesting viable solutions exist but are abandoned prematurely.
o1-like models frequently abandon reasoning paths mid-exploration, wasting tokens on incomplete approaches. A decoding-only penalty on thought-transition tokens (TIP strategy) discourages switching, improving accuracy on challenging math without model fine-tuning.
The MathIF benchmark shows that SFT and RL training improve reasoning but reduce instruction adherence, particularly as chain-of-thought length increases. Longer reasoning chains create contextual distance that dilutes the model's attention to original instructions.
Advanced reasoning models achieve only 50.71% instruction adherence during mathematical reasoning. Training for reasoning depth actively worsens instruction compliance, suggesting a fundamental trade-off between reasoning power and controllability.
Saliency analysis reveals that CoT prompting fails when question information doesn't aggregate into the prompt structure before reasoning begins. For simple questions, direct question-to-answer flow outperforms step-by-step reasoning, showing the optimal prompt depends on question type, not just task category.
Task accuracy peaks at intermediate CoT length, with optimal length increasing alongside task difficulty but decreasing with model capability. RL training naturally gravitates toward shorter chains as models improve, revealing that simplicity emerges from reward signals rather than explicit training.
Increasing thinking tokens from ~1,100 to ~16K reduced benchmark accuracy from 87.3% to 70.3%, revealing a non-monotonic relationship where models overthink easy problems and underthink hard ones.
SAE-identified reasoning features can be directly steered to match or exceed chain-of-thought performance across six model families. This reasoning mode activates early in generation and overrides surface-level instructions, suggesting latent reasoning is a fundamental capability independent of explicit prompting.
Depth-recurrent and compressed-token architectures solve reasoning tasks through hidden computation rather than output tokens. A 27M-parameter model solved Sudoku-Extreme and 30×30 mazes perfectly while CoT methods scored zero.
Reliability for long-trace reasoning comes from checking intermediate states and policy compliance during generation, not from scoring final outputs. Adding intermediate verification raised task success from 32% to 87% because most failures are process violations, not wrong answers.