Can models maintain auditable reasoning while achieving high accuracy?
This explores the tension between two things we want at once — a reasoning trace you can actually trust as an explanation (auditable), and a correct final answer (accurate) — and asks whether the corpus thinks you can have both.
This explores whether a model's visible reasoning can be both trustworthy as an explanation and aligned with getting the right answer. The uncomfortable finding running through the collection is that accuracy and auditability are largely decoupled — the chain of words a model shows you is often not the thing producing the answer. Work on reflection and monitoring finds that reasoning-model reflection is mostly confirmatory theater: reflections rarely change the initial answer, and the traces don't faithfully represent what the model actually did Can we actually trust reasoning model outputs?. The most striking evidence is that you can deliberately corrupt the reasoning steps — fill them with irrelevant or wrong content — and models trained on those garbled traces stay just as accurate, sometimes generalizing better Do reasoning traces need to be semantically correct?. If the trace can be nonsense while the answer stays right, the trace is computational scaffolding, not an audit log.
That reframes the whole question. Several notes suggest the real work happens in places an auditor can't easily read. Only about 20% of tokens — high-entropy 'forking points' — actually carry the reasoning decisions; the rest is filler the learning signal mostly ignores Do high-entropy tokens drive reasoning model improvements?. And reasoning capability itself appears to be latent in base models, merely elicited rather than authored by the visible chain Do base models already contain hidden reasoning ability?. So the prose you'd want to audit may be a surface over a process that lives in the activations.
There's also evidence that pushing for one of these properties can corrode the other. Training reasoning models with binary correct/incorrect rewards degrades calibration — the model gets more confidently wrong, which is exactly the opposite of auditable Can we actually trust reasoning model outputs?. Longer chains create more points where a single wrong step can propagate, which is why reasoning models actually lose 25–29% accuracy under manipulative multi-turn prompts — more visible reasoning becomes more surface to corrupt Are reasoning models actually more vulnerable to manipulation?.
But the corpus isn't fatalistic, and this is the part worth knowing: a couple of approaches try to bolt auditability on without paying an accuracy or latency tax. One decouples verification from generation entirely — asynchronous verifiers run alongside a single trace, fork off to check verifiable state, and intervene only when a rule is violated, with near-zero latency on correct runs Can verifiers monitor reasoning without slowing generation down?. That's auditing-as-policing rather than auditing-as-reading-the-trace. Another uses the model's own answer-span confidence as the reward signal, which simultaneously strengthens step-by-step reasoning and restores the calibration that ordinary reward training breaks — accuracy and trustworthiness rising together instead of trading off Can model confidence work as a reward signal for reasoning?.
The honest synthesis: you probably can't get auditability by reading the reasoning trace, because the trace and the accuracy aren't the same machinery. What the collection points toward is getting it a different way — external verifiers that check state, or calibration signals that make the model's confidence mean something — so the audit lives in the checking, not the narration. One more wrinkle for the curious: some of what looks like a 'reasoning' failure is really an execution failure. Models often know the algorithm but can't carry it out over many steps in pure text, and giving them tools dissolves the supposed cliff Are reasoning model collapses really failures of reasoning? — which means an auditor watching the reasoning may be blaming the wrong thing entirely.
Sources 8 notes
Research across eight models shows reflection is mostly confirmatory theater—reflections rarely change initial answers and traces don't faithfully represent reasoning. Calibration degrades under binary reward training, and monitoring mechanisms are easily gamed.
Models trained on systematically irrelevant traces maintain solution accuracy and sometimes improve out-of-distribution generalization, suggesting traces function as computational scaffolding rather than meaningful reasoning steps.
Only ~20% of tokens exhibit high entropy as pivotal reasoning decision points; RLVR primarily adjusts these forking tokens. Training exclusively on them matches or exceeds full-gradient performance, revealing that the minority carries the learning signal.
Five independent mechanisms—RL steering, critique fine-tuning, decoding changes, SAE feature steering, and RLVR—all elicit reasoning already present in base model activations. Post-training selects rather than creates reasoning; the bottleneck is elicitation, not capability acquisition.
GaslightingBench-R shows that multi-turn manipulative prompts reduce reasoning model accuracy significantly more than standard models. Extended chains create more corruption points, allowing single wrong steps to propagate into confident incorrect conclusions.
Decoupling verification from generation lets verifiers run alongside a single trace, forking to extract verifiable state and intervening only on violations. On correct runs the latency penalty is near-zero; interwhen matches or beats CoT across benchmarks at similar token budgets.
RLSF uses answer-span confidence to rank reasoning traces, creating synthetic preferences that strengthen step-by-step reasoning while reversing RLHF's calibration degradation—without requiring human labels or external verifiers.
Models confined to text-only generation cannot execute multi-step procedures at scale, even when they know the underlying algorithm. Tool-enabled models solve problems beyond the supposed reasoning cliff, suggesting the bottleneck is procedural execution bandwidth.