What is it?
Reasoning models "think" before answering. Many providers do not hand you that raw thinking: you may get a summary, a redacted version, or nothing, and the thinking usually still counts toward cost.
For builders the practical rule is simple: design around the final answer and a short justification written for the user. Don't build features that depend on seeing — or extracting — hidden reasoning, and don't treat any visible reasoning as proof of why the model answered as it did.
Also known as: hidden chain of thought, private reasoning, reasoning summaries, reasoning traces, thinking tokens, reasoning tokens, raw chain of thought, CoT faithfulness.
Technical definition
Reasons commonly given for withholding raw reasoning include safety monitoring, competitive concerns, and the observation that reasoning text may be unfaithful or messy. Research on chain-of-thought faithfulness shows displayed rationales can omit or misstate the real drivers of an answer, so they are weak evidence for auditing. Provider policies differ (full, summarised, redacted, or none), may change, and are governed by terms of use. Attempting to elicit concealed reasoning against provider policy can breach those terms and is not a supported practice.
Entity type: concept · Freshness class: volatile.
When should I use it?
Apply this whenever you build user-facing or regulated features on reasoning models and need to explain, audit or log decisions.
Implementation patterns
- Design for the final answer: tests and acceptance criteria apply to outputs and tool calls, not to hidden text.
- Generate a purpose-written justification (cite sources, list assumptions) as a normal output field.
- Audit by logging inputs, retrieved sources, tool calls and final outputs.
- Use independent checks (tests, rules, retrieval evidence) for high-stakes decisions rather than a model's own explanation.
- Honour provider rules about storing or displaying any reasoning content they do return.
Technologies and frameworks
Commonly associated: provider reasoning summaries, structured "justification" fields, audit logs of inputs, tools and outputs. Names are examples of what exists, not recommendations, and projects change quickly.
Practical guide
- Read your provider's current policy on reasoning content and billing.
- Decide what end users need: sources and a justification, not raw traces.
- Add a "justification" or "evidence" field to your output schema (Structured Outputs from LLMs).
- Log inputs, sources, tool calls, outputs and versions for audit.
- Review privacy implications of any reasoning content you do retain (AI Privacy and Security: What to Know Before You Paste Data).
Common failure modes
- Building a product feature that depends on raw reasoning being available.
- Presenting a reasoning summary to users as "why the AI decided" when it may not be faithful.
- Storing returned reasoning content longer or more widely than your privacy policy and provider terms allow.
- Trying to prompt the model to disclose concealed reasoning, which may violate terms and is unreliable.
- Assuming no visible reasoning means no cost — reasoning tokens are often billed.
Troubleshooting
- Users want to know why the AI said that — Show sources, assumptions and a short justification you asked for as normal output, plus a way to challenge or review it.
- Cost is higher than visible output suggests — Check usage fields for reasoning-token counts and lower effort or budget.
- Need an audit trail — Log inputs, context sources, tool calls, outputs and model/version; do not rely on reasoning text.
Contrasted with
- Chain-of-Thought Prompting — CoT prompting produces visible text you asked for; hidden reasoning is internal text the provider chooses whether to return.
- Mechanistic Interpretability — Interpretability inspects internal computation of the model; a reasoning trace is generated text, not a direct readout of that computation.
Questions this page answers
- Why do providers hide chain of thought?
- Can I see a reasoning model's thinking?
- Are reasoning summaries accurate explanations?
- How should I explain AI decisions to users?
- Do reasoning tokens cost money?
Typical goals: understand why providers hide reasoning; show users an explanation safely; audit model decisions without relying on traces.
Sources and verification
Status: not independently verified. This entry was authored on 2026-10-06 from general technical knowledge, without live checking of the sources below. Treat every source as a lead to confirm (identifier, title, authorship, current version) before publication or citation.
Freshness class: volatile — Products, versions, protocols, benchmarks, leaderboards, regulations and dates. Verify against the primary source before relying on specifics; re-review every 3 months.
Time-sensitive claims to verify before relying on them:
- Which providers return full, summarised or no reasoning, and under what terms.
- How reasoning tokens are billed and reported.
- Any claim about why a particular provider withholds reasoning.
Canonical sources (unverified leads):
- Turpin et al., Language Models Don't Always Say What They Think (2023) — arXiv:2305.04388
- Lanham et al., Measuring Faithfulness in Chain-of-Thought Reasoning (2023) — arXiv:2307.13702
- Provider documentation and usage policies on reasoning content — locator to be identified