How does chain-of-thought training change higher layer computations?
This explores what chain-of-thought training actually changes inside a model's computation — and here the corpus speaks at the behavioral and functional level rather than the layer-by-layer mechanistic one, so the honest answer is about what CoT training reshapes, not which layers light up.
This reads as a question about internal mechanism — what happens deep in the network when you train on reasoning traces. Worth saying upfront: this collection doesn't contain layer-resolved interpretability work (no probing of attention heads or residual streams by depth), so it can't tell you what 'higher layers' do in the literal mechanistic sense. What it can tell you is something arguably more useful — what CoT training changes about the *computation* the model performs, and the picture is consistent and a little deflating.
The recurring finding is that training on chain-of-thought installs reasoning *form* rather than reasoning *capability*. CoT systems reproduce familiar reasoning schemata through pattern matching, which is why structurally invalid prompts work as well as valid ones and why training format shapes the reasoning strategy roughly 7.5× more than the actual problem domain Does chain-of-thought reasoning reveal genuine inference or pattern matching? What makes chain-of-thought reasoning actually work? What makes chain-of-thought reasoning actually work?. The computation being learned is closer to 'recall and replay a matching trace' than 'execute a logical procedure.' That's confirmed from the outside: controlled experiments show CoT degrades predictably the moment you shift task, length, or format away from the training distribution — fluent output, broken logic Does chain-of-thought reasoning actually generalize beyond training data?. Trace length itself turns out to track *proximity to training schemas*, not problem difficulty, decoupling entirely out-of-distribution Does longer reasoning actually mean harder problems?.
The closest thing here to a claim about deeper computational structure is the faithfulness work, and it cuts in an interesting direction: fine-tuning actively *weakens* the causal link between the reasoning steps and the final answer. After fine-tuning, you can truncate, paraphrase, or stuff filler into the chain and the answer often doesn't move — the reasoning becomes performative rather than load-bearing Does fine-tuning disconnect reasoning steps from final answers?. So one thing training demonstrably changes is *where the answer is actually computed* — increasingly somewhere other than the visible chain. The attention-map evidence points the same way: verification and backtracking steps receive almost no downstream attention, meaning the model's later computation simply ignores large portions of its own stated reasoning Can reasoning steps be dynamically pruned without losing accuracy?. And much of the chain is removable with no accuracy loss — 92% of tokens in standard CoT served style and documentation, not computation Can minimal reasoning chains match full explanations?.
There's a contrasting thread worth chasing, because not all training is equal. Some approaches try to bake genuine computational procedure into the model rather than surface form: Meta-CoT trains on linearized search-algorithm traces (MCTS, A*) so the model internalizes the *search process* itself, optimizing over algorithms rather than memorizing outputs Can models learn to internalize search algorithms through training?. And RLP plants reasoning during pretraining using information-gain as a verifier-free reward, lifting reasoning ~19% — a hint that *when* in training you introduce CoT changes how deeply it's integrated Can chain-of-thought reasoning be learned during pretraining itself?. There's also evidence the model's internal economy self-adjusts: RL training naturally gravitates toward *shorter* chains as the model gets more capable, suggesting brevity emerges from reward pressure rather than being trained in Why does chain of thought accuracy eventually decline with length?.
The thing you might not have known you wanted to know: the question assumes the visible reasoning chain reflects the model's internal computation. The corpus's most striking result is that training progressively *breaks that assumption* — the chain drifts toward decoration while the real work relocates elsewhere. If you want the genuine mechanistic, layer-level answer, that's a gap to fill from elsewhere; what this collection establishes is the behavioral shadow that any such account has to explain.
Sources 11 notes
CoT works by constraining models to reproduce familiar reasoning patterns from training, not by enabling novel symbolic reasoning. Performance degrades predictably under distribution shifts—the signature of imitation rather than capability emergence.
Research shows training format shapes reasoning strategy 7.5× more than domain, demo position swings accuracy 20%, and invalid CoT prompts work as well as valid ones. CoT is pattern-guided generation, not formal logic.
CoT systems reproduce the form of reasoning through pattern matching rather than performing genuine logical inference. This explains why format effects dominate content, why structurally invalid prompts succeed, and why stronger reasoning models become less instruction-compliant.
DataAlchemy experiments show CoT fails systematically under distributional shifts in task, length, and format. Models produce fluent but logically inconsistent reasoning — imitating reasoning form without valid underlying logic.
Controlled A* maze experiments show trace length correlates with difficulty only in-distribution but decouples entirely out-of-distribution. Trace length primarily reflects recall of training schemas, not adaptive computation.
Three faithfulness tests show fine-tuned models generate reasoning chains that less reliably influence final outputs. Early termination, paraphrasing, and filler substitution all produce invariant answers more often after fine-tuning, suggesting reasoning becomes performative rather than functional.
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.
Chain of Draft achieves equivalent accuracy to standard chain-of-thought on arithmetic, symbolic, and commonsense tasks while using only 7.6% of tokens. The 92.4% of removed tokens served style and documentation, not computation.
Meta-CoT demonstrates that instruction-tuning on linearized MCTS and A* traces teaches models to implement search strategies internally. This enables optimization over algorithms themselves rather than specific outputs, potentially unlocking novel reasoning strategies.
RLP treats CoT as exploratory action during pretraining, using log-likelihood improvement as verifier-free reward. Applied to Qwen3-1.7B and Nemotron-Nano-12B, the method improves math and science benchmarks substantially, suggesting reasoning can be planted earlier in training.
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.