Chain-of-thought is a bad explanation and a good sensor.
The two questions people ask about chain-of-thought have different answers, and treating them as one question is why teams either file the trace as an audit log or throw it away as a post-hoc story. It is a poor explanation — that has not changed. But OpenAI's CoT-Control work, published in March 2026 across 13 reasoning models, measured something else entirely: whether a model can suppress what its reasoning reveals. Claude Sonnet 4.5 controlled its chain of thought 2.7% of the time against 61.9% for its final output. The trace is a weak explanation and a high-recall sensor, and the sensor's reliability degrades exactly where you are most likely to push.
Step 1What CoT buys: serial compute, not introspection.
A transformer does a fixed amount of computation per forward pass. CoT works because each emitted token becomes input to the next pass, so writing intermediate steps lets the model spend more serial compute and externalize state it cannot hold in activations. That is the entire mechanism. It explains the empirical pattern: CoT helps most on compositional, multi-hop tasks (arithmetic, symbolic manipulation, multi-constraint planning) and barely moves single-hop tasks (lookup, sentiment, simple classification) where the answer needs no decomposition.
The practical consequence of that mechanism has moved, though, and it is worth being blunt about it: on current reasoning models you are mostly no longer the one deciding. The 2022-era lever was a prompt — let's think step by step — and the 2026 lever is a parameter. Effort or thinking-budget settings now control how much serial compute the model spends, and the model itself allocates within that budget; the mechanics are in adaptive thinking and effort budgets, and the per-token billing consequences in reasoning token accounting. Instructing a reasoning model to reason is at best redundant and can fight the model's own allocation.
So the interesting decision about CoT is no longer whether to ask for it. It is what you do with the artifact that comes back — and whether you can still see it at all.
Step 2Faithfulness: the trace is often a post-hoc story.
The dangerous misconception is treating the CoT as an audit log. Models steered by a hint or a planted bias will produce a fluent rationale that never mentions the actual cause and instead justifies the biased answer — implicit post-hoc rationalization. Rates vary sharply by model class: instruction-tuned non-reasoning models rationalize binary-question biases at meaningfully higher rates than RL-trained reasoning models, where faithfulness on those probes is far better but still not perfect. Models also silently self-correct (make an error mid-trace, fix it later without flagging it) and take unfaithful shortcuts (illogical leaps that happen to land on the right answer). The measurement problem is its own subject in chain-of-thought faithfulness.
Causal-intervention studies — perturb a step, see if the answer moves — add a useful split. Distilled reasoning models depend on their CoT far more heavily than instruction-tuned models: they revise an initial answer after reasoning at multiple times the rate, and frequently correct genuine mistakes. Practically, a model whose answer is causally downstream of its trace is one where editing an intermediate step is a real lever; a model that emits CoT decoratively will ignore your corrections. Probe which regime you are in before building tooling on top of the trace.
Do not use the CoT as a compliance artifact or an explanation of record. "The model explained its reasoning" is not evidence the stated reasons are the operative ones, and in a regulated workflow an unfaithful explanation is worse than none — it is a document that will be relied upon. If you owe someone a reason, derive it from the inputs and the decision rule, not from the model's prose.
Step 3Controllability is a different property, and it was measured.
Here is the finding that reframes the page. Faithfulness asks: did the stated reasons cause the answer? Monitorability asks a weaker and much more useful question: does misbehaviour leave a mark in the trace? Those come apart, because a trace can be an unreliable account of the cause while still being an unreliable concealment of it.
OpenAI's CoT-Control evaluation suite and paper (March 2026) tested 13 reasoning models on whether they could steer their own chains of thought — keep a topic out, avoid naming a concept, obscure an approach. All of them struggled. The gap against final-output control is the striking part, because it isolates the effect: these models are good at controlling what they say and bad at controlling what they think on the way there.
# CoT-Control (OpenAI, March 2026) — control success rate final output chain of thought Claude Sonnet 4.5 61.9% 2.7% GPT-5.4 Thinking - 0.3% # at 10,000 chars # reported directional findings: controllability UP with model size DOWN with longer thinking DOWN with more RL training DOWN with harder problems slightly UP when told it is being monitored
OpenAI's own framing is that low controllability makes CoT monitoring more trustworthy as a safeguard, and that frontier labs should track controllability in future models. Note what kind of claim that is: the trace is useful as a sensor not because anyone engineered it to be honest, but because the model cannot currently help itself. That is an accident of capability, not a property of design — which is precisely the argument of the 41-author position paper Chain of Thought Monitorability: A New and Fragile Opportunity for AI Safety (Korbak et al., arXiv 2507.11473, with co-authors across OpenAI, Google DeepMind, Anthropic, Apollo Research and the UK AI Security Institute; v2 December 2025). Their case is not that reading the trace is a silver bullet. It is that the window may close.
The CoT-Control authors are clear that their tasks are practical proxies rather than tests of models naturally pursuing misaligned goals, and commentators have noted that steering a chain of thought to excuse a behaviour is a separate risk the suite does not measure. Take the result for what it supports: as of early 2026, suppression is hard, so absence of a signal in the trace is weak evidence of absence, and presence of one is strong evidence worth triaging.
Step 4Where CoT hurts, and where the sensor gets worse.
CoT is not free upside. It degrades performance when verbalization disrupts an otherwise good intuition — some perceptual, pattern-completion and implicit-statistical tasks get worse with forced reasoning, the overthinking failure. It compounds errors on long chains: a wrong early step is confidently elaborated for hundreds of tokens. And past a problem-dependent point, extra reasoning on a single trace tends to wander, anchor on an early mistake, or talk itself out of a correct answer — the shape of which is mapped in inverse scaling in test-time compute, and the task-level decision in when reasoning helps.
What is new is that the capability curve and the monitoring curve point the same way, and that is the uncomfortable part. Every lever that buys accuracy on hard tasks — more RL training, longer thinking, pushing the model to the edge of its competence — is a lever CoT-Control reports as reducing controllability. On the monitoring reading that sounds like good news, and for now it is. But the same levers are the ones the monitorability paper names as threats to the window, via training pressure on the trace and architectures that move reasoning into activations. If reasoning migrates off the token stream entirely, the sensor does not degrade — it disappears, which is the subject of latent reasoning.
There is a second-order trap worth naming, because it is the one teams walk into on their own. Once you monitor the trace, the tempting next step is to train against the monitor — penalise traces that mention the thing you do not want. OpenAI's earlier work on detecting misbehavior in frontier reasoning models recommends against applying strong optimization pressure directly to the CoT, for the obvious reason: you get a model that stops saying it and does not stop doing it. Monitor the trace; do not optimise it.
Step 5Structured CoT for what you program against, raw CoT for what you monitor.
These are two different artifacts for two different consumers, and conflating them is the old mistake in a new form. Free-form CoT maximizes a benchmark number; structured output maximizes operability. Constrain what your code reads into named, parseable slots:
# Structured trace: each field is checkable downstream { "given": ["facts extracted from the prompt"], "plan": ["step 1", "step 2"], "work": "the actual derivation", "answer": "final", "checks": ["unit check passed", "bounds ok"] }
A structured block turns prose into a contract: you can validate checks, gate on a missing plan, diff given against the prompt for hallucinated premises, and route answer without regex-scraping a paragraph. What it is not is your monitoring signal. A structured field is content the model chose to put in a slot you defined — which is the final-output channel, the one CoT-Control says models control at 61.9%. The sensor lives in the channel they do not control.
So keep both, and keep them separate:
- Structured output — what your code branches on. Validate it, gate on it, store it with the decision. Treat it as an assertion by the model, not as evidence about the model.
- Raw reasoning — what your monitors read. Never shown to a user as an explanation, never parsed for business logic, never trained against. Scanned for the things you care about catching, with hits routed to review rather than to an automatic block, in the posture described in monitor integrity.
The second of those has a hard dependency most teams discover late: you have to still be able to get the raw trace, and you have to be allowed to keep it. Reasoning content now arrives as signed, encrypted or summarized blocks whose handling rules differ by vendor, and some of them you must return unmodified rather than store — the mechanics, including the prefix rules that break ordinary middleware, are in carrying reasoning across tool calls. Trace visibility is a procurement question, and it should be on the list before you build a monitor that assumes it.
Step 6The honest trade-off.
CoT buys accuracy on decomposable problems by spending serial compute; it is a generation strategy rather than an explanation, and it is simultaneously the cheapest high-recall sensor you have on an agent's intent. Those two facts are not in tension, and the cost of merging them is paid in both directions — teams that trust the trace ship an unfaithful explanation into a compliance workflow, and teams that dismiss it delete a signal that catches more than monitoring actions and outputs alone.
The genuinely open question is how long the sensor lasts. It works today because models are bad at suppression, and both the capability trend and the architectural trend run against that. Nobody has shown how to monitor reasoning that was never serialized, and probe-based approaches need white-box access that a hosted model does not give you. Plan as though your current trace-based monitors have a shelf life measured in model generations, and make sure the controls that do not depend on reading the trace — a tool-call allowlist, egress control, a human in the loop at the irreversible step — would still be there if it went dark tomorrow.
Do this: separate the two consumers in your own stack today. Define a structured output block for everything your code reads, and stop regex-scraping prose for decisions. Then take fifty production reasoning traces, hand them to whoever investigates your incidents, and ask what they would have caught — that number is what your trace is worth as a sensor, and it is the number to re-measure after every model upgrade. Before the next one, confirm two things with your provider: that you can still retrieve the reasoning content, and whether you are permitted to retain it. If the answer to either is no, you do not have a trace-based monitor; you have a plan to build one.