Progressive Disclosure of AI Reasoning

Showing the model thinking is the most effective thing you can put on screen during a thirty-second wait, and the most dangerous thing to label as an explanation. Both facts come from the same place: it looks exactly like reasoning.

What you are actually showing

A reasoning model generates tokens before its answer, and those tokens are billed at the output rate whether or not you display them — see reasoning tokens. What you can put on screen varies by provider and is worth knowing precisely before designing around it:

• Raw thinking tokens, streamed as generated. Long, repetitive, full of abandoned branches, and occasionally containing statements the model later rejects. Honest and hard to read.
• A provider-generated summary of the thinking. Much more readable, and a second generated artefact — a summary of a process, not the process.
• Nothing. Some providers do not expose it at all, while still charging for it. Your design cannot depend on having it.
• Real pipeline events — retrieval, tool calls, sub-steps. Not model reasoning at all. These are actual observed system behaviour, and they are the most trustworthy thing in this list. See streaming reasoning output.

Two good reasons to show it

It fills the wait with something true. A reasoning model can spend tens of seconds before the first visible token, which is past every response-time limit in the loading-state page. Displaying real activity is the operational-transparency effect discussed in streaming UX — and it is legitimate here specifically because the work is real. The same treatment applied to a fabricated “analysing…” sequence would be theatre.

It lets a user spot a wrong turn early. If the visible reasoning shows the model has misread the question, the user can cancel at four seconds rather than reading a wrong answer at forty. This is a genuine and underrated benefit, and it is about the input — you are not verifying the logic, you are noticing that it started from the wrong premise.

Why it is not an explanation

The prohibition is the important part of this page. Displayed reasoning is generated text that precedes the answer. Whether it describes the computation that produced the answer is an open research question, and the evidence that chain-of-thought traces can be unfaithful — that a model can be influenced by a factor its stated reasoning never mentions — is well enough established to make any audit-trail framing irresponsible. See whether stated reasoning is faithful.

Three consequences for the interface, and all three are about what you must not do:

• Do not label it “why”, “explanation” or “rationale”. “Thinking” and “steps” describe what happened without claiming a causal relationship.
• Do not retain it as a compliance artefact. A regulator asking why a decision was made will not be satisfied by generated prose that may not describe the cause, and offering it as though it were an audit trail is worse than having none.
• Do not let its length or fluency stand in for correctness. This is automation bias in a new costume: a long, articulate chain increases reliance regardless of whether the conclusion is right, and a wrong answer with visible reasoning is more persuasive than a wrong answer without.

The disclosure pattern

Progressive disclosure is the right structure — the summary carries the value, the detail is available for the minority who want it — and the behaviour over the lifetime of a request matters more than the styling.

Before the first answer token
  expanded by default, scrolling, latest line visible
  header: "Thinking" + elapsed
  this is the wait state; it is the most useful thing on screen

On the first answer token
  auto-collapse to a single row: "Thought for 24s"  [chevron]
  the answer takes the primary position immediately

After completion
  collapsed; expandable; state persisted per turn
  a user who expands it once should not have to re-expand
  every turn, and a user who never opens it should never
  see it again

Never
  auto-expand a completed reasoning block
  animate the collapse in a way that shifts the answer
  put reasoning above the answer in the reading order
    once the answer exists

The auto-collapse on first token is the whole pattern. Before it, the reasoning is the only content; after it, the reasoning is a footnote. Getting that transition right is what separates a reasoning display that helps from one that buries the answer under eight hundred words of deliberation.

It is not free

Two costs worth stating plainly. Reasoning tokens are billed at the output rate and there are often many of them, so a feature that reasons is materially more expensive per interaction than one that does not — the display is free but the thing being displayed is not. And a reasoning display invites users to read it, which spends the attention you wanted them to spend checking the answer.

Which suggests a default worth defending: reason where the task needs it, show the reasoning where the wait would otherwise be empty, and collapse it the moment there is an answer to look at instead.

One more consideration belongs in the decision, and it is not a design one. Reasoning text is generated without the presentation constraints the answer is written under. It can be blunt about the user, speculate about their motives, reason about your system prompt, or work through a request in terms you would not put in front of a customer. Displaying it raw is a decision to publish a draft nobody edited, which is survivable in a developer tool and a real risk in a consumer product — and it is the strongest argument for preferring a provider summary or a phase display over the unfiltered trace.

The pipeline-events option in the list above is underrated for exactly this reason. “Searching 4 documents”, “calling the pricing API”, “checking 3 sources” are observed system behaviour rather than generated text. They fill the wait, they cannot say anything embarrassing, they are genuinely machine-verifiable, and unlike a reasoning trace they describe something that actually happened. Where your feature has real steps, show those and leave the model’s deliberation collapsed.