[FEATURE] Stream Claude's thinking live in the CLI — the spinner says it's thinking; we'd like to know what

Preflight Checklist

• [x] I have searched existing requests and this feature hasn't been requested yet
• [x] This is a single feature request (not multiple features)
• [x] We have read our own invoices and confirmed we already pay for the thing we cannot see

Problem Statement

We should say up front that we are not funny people. What follows is not a joke. It only behaves like one.
A bit like Claude's gerunds, which behave like thinking.

Our terminals know something we don't. Every session. All sessions.

✻ Proofing… (15s · ↓ 325 tokens)
✻ Marinating… (34s · ↓ 812 tokens)
✻ Almost done thinking

Proofing what? Marinating in what? The ↓ is tokens arriving — hundreds of them, counted live, readable by no one. We know exactly how much thought has occurred, only not what it was. It is difficult to think of another profession that bills this way.

Esc still interrupts; that is not the complaint. It is a working emergency brake on a ship in hyperdrive: we may pull it whenever we like, and we will find out where we were going when we arrive, having spent all our tokens.

To be clear, we love the verbs. Whoever writes the verbs should never stop.
This issue does not threaten the verbs. We are asking for _subtitles_.

Recently the model thought for ninety seconds and emerged with a flawless plan for the wrong problem.
It was an exceptionally good answer to a question nobody had asked. The misunderstanding will have happened around second four. We were present the entire time, equipped to interrupt the reasoning at any moment, but not to observe it once.

On claude.ai/chat, thinking is visible — one of us watched Fable think this very afternoon. We can watch it go wrong in real time. In Claude Code, the tool built for the people most likely to want a raw trace, we get one gerund, a stopwatch, and a running total of words apparently too dangerous for their owner.

And the institutional context makes it stranger. Anthropic is the interpretability company.

You once built a version of Claude that could not stop thinking about the Golden Gate Bridge, and you showed it to everyone — on purpose, as a demo. Somewhere else inside Anthropic, researchers are publishing papers on extracting concepts from transformers. Here, we are opening a GitHub issue asking whether the spinner could be slightly more forthcoming.

We do not imagine this is an oversight. A company that can locate the Golden Gate Bridge inside a neural network has not accidentally misplaced a checkbox. Hiding the thinking is a chosen position, and our best reconstruction of the reasons is offered below, with respect. But a chosen position is a lever, and levers are moved by the public leaning on them politely, in writing, where everyone can see. Consider this card our lean.

What the community has established, in lieu of documentation:

• "showThinkingSummaries": true exists, defaults to false, and yields summaries — post-hoc, truncated, and written about the thinking by another model.
• A working incantation (CLAUDE_CODE_EXTRA_BODY with thinking.display: "summarized") circulates via a comment on #54348, passed hand to hand like samizdat. The env var is documented; the payload is not.
• Multiple users report the last model to stream full raw traces was Sonnet 3.7, and that everything since is summarized or omitted at the API layer itself.
• Yet a Bedrock user reports pages of detailed thinking streaming through a different harness on the same endpoint the CLI uses. The ceiling is reportedly higher than the CLI's floor.
• The prevailing folk theory for all of it is anti-distillation. There has been no official confirmation or denial.

None of the above comes from the documentation. Reddit currently serves as the documentation, oral tradition, and archaeological record. We mention this not as a complaint but because it makes layer 1 of the proposal unusually cheap and unusually valuable.

Proposed Solution

In descending order of ambition; each layer stands alone:

1. Document the truth.

One paragraph: which display modes exist (raw / summarized / omitted), per model and per provider, and whether raw traces still exist at all. This costs one docs PR and ends the samizdat.

1. Make summarized display first-class.

Surface it in /config; retire the env-var incantation.

1. A live toggle.

One rebindable keypress (Ctrl+O is taken; Alt+T toggles whether thinking happens — this toggles whether we watch) flips the thinking display on and off mid-session. Raw thinking will often be overwhelming; the correct UX for overwhelming is not "unavailable," it is "one keypress away, in either direction."

1. Where the provider supports richer display — Bedrock reportedly does — pass it through.

"showThinking": "raw" | "summary" | "collapsed" | "hidden", with showThinkingSummaries: true as a back-compat alias for summary. Render redacted_thinking stubs as exactly what they are.

Strictly additive. Possibly addictive. Nobody need opt in. Some of us would - Enthusiastically.

What would resolve this issue — even "no" counts, if it comes with a number:

To be explicit, since we tested it ourselves: enabling showThinkingSummaries does not resolve this — that flag is bullet one above, and it surfaces a second model's after-the-fact paraphrase, in blocks, not the live raw reasoning. We are asking for the raw stream as it is generated; or, if no such stream exists for interactive clients, a plain statement in the docs that it does not. Either one resolves this. "Use the flag you documented nowhere" does not.

1. Ship any layer above. (Preferred, obviously.)

1. "It's upstream at the API." Then this issue becomes the signpost that saves the next person the archaeology.

1. "Wontfix, because reason #N in the steelman" (see Additional Context) — or the reason we missed.

One sentence from a maintainer would save several hundred from everyone else.

The only outcome we'd mourn is the unlisted fourth, where this stays open for two years and is closed by a bot with no verb at all.

Alternative Solutions

• Reading the verbs like tea leaves. ("'Befuddling…' — our code, or its plan? Both? It's us, isn't it.")
• MAX_THINKING_TOKENS=0, so there is nothing to miss. Solving loneliness by unplugging the telephone. No.
• Career change. Join Anthropic's interpretability team, spend several years learning to read a model's thoughts in neuron space, then continue not reading them in Claude Code.
• Acceptance. Ongoing. Results poor.

Priority

Medium - Would be very helpful

Feature Category

Interactive mode (TUI)

Use Case Example

An operator runs a long agentic session — a refactor, a migration, an autonomous loop. Today, the earliest signal that the model has misread the goal arrives after the plan is complete: minutes and thousands of thinking tokens later. With live thinking display, the misreading is visible in the first seconds of reasoning, and the operator interrupts immediately, corrects course, and re-runs — saving the tokens, the wall-clock time, and the wrong diff. When orchestrating multiple sessions, this compounds: the thinking is the earliest steering signal there is, and it is currently the only one hidden.

Secondary cases, all real: learning (watching the model reason about an unfamiliar codebase is the fastest tour of the codebase); debugging surprising decisions (the "why did you do that?" round-trip disappears when you watched the why); and trust calibration (knowing whether the model is confident or flailing changes how much scrutiny its output gets).

Additional Context

Why this may not have shipped — our best attempt at your side of the argument:

1. The thinking isn't testimony.

Your researchers published "Reasoning Models Don't Always Say What They Think" — a genuinely great title. Stream it raw and someone will file "Claude's thinking said tabs, then it used spaces, WHO IS DRIVING." Label it drafts, not commitments. We will co-sign.

1. You don't want product pressure on the monitoring channel.

The serious argument: chain-of-thought is a safety surface, and the moment it becomes a consumer surface, product will want it nicer, and training it nicer fogs your own telescope. Counterpoint: an opt-in toggle in a developer CLI is not a consumer surface. We read stack traces recreationally. We are who the drafts folder is for.

1. The drafts may contain the contraband.

The thinking is where the model works out what to refuse, so the harmful material can transit the reasoning before the polite no arrives. This is presumably why redacted_thinking blocks exist: reasoning that trips the safety systems arrives encrypted. If so, the scalpel already exists — selective encryption of exactly the dangerous part already ships. A curtain over everything else may no longer be necessary.

1. Distillation.

The folk consensus is that rival labs were training on the traces. Which would mean every developer on Earth lost the window because somebody was photocopying the homework. For what it's worth: we are not a distillation threat. We cannot read at the speed the model thinks. Some of us move our lips.

1. There may be nothing left to show.

The most unsettling rumour: newer models reason in latent space, and what used to be the chain of thought is now written afterwards, by a smaller model, as coverage. If true, raw thinking doesn't exist, and this issue is a queue forming to meet the author of a book that was generated. That would be a complete answer — one paragraph in the docs saying so would close half a dozen issues and end the folklore, and we would accept it entirely.

1. Cost.

Our own theory arriving here, hereby retracted, because the docs state verbatim: "You are charged for all thinking tokens generated, even when collapsed or redacted." That sentence rewards a second read. Somewhere in a datacentre there exists a complete account of everything the model has ever thought about our code. We paid for all of it. We have never read a word. There are marriages like this.

Related issues:

| Issue | What it establishes |
|---|---|
| #69278 | A past update replaced visible streamed thinking with a token counter; asks for restoration |
| #36006 | Collapsed-by-default display with a toggle — largely shipped, as summaries |
| #33163 | "Bring back thinking" — cites a 68-upvote predecessor, auto-locked |
| #71923 | The same wish, less specified |
| #62672 | The summary rendering behavior is itself under-documented |
| #54348 | Closed, but its comments are where the community found the display workaround |
| #63335 / #63147 | Thinking-block signatures 400-wedge sessions — the machinery is live and load-bearing |
| #75916 | Messages meant for the user arrive as encrypted thinking, unrecoverable — the curtain sometimes eats the letter too |
| #76031 | The "almost done thinking" estimate is a wall-clock guess |

We are happy for this to be closed as a duplicate, if the canonical issue carries the raw-vs-summary distinction. None currently does.

Environment: Claude Code v2.1.205, Linux, first-party Anthropic (Max 20x subscription), interactive mode.

Closing statement.
Underneath all of this is a much simpler request. We would like to watch the model change its mind.

The response is polished. It was written for us. The thinking exists before it knows we are looking. It is the only text in the session with no reason to be agreeable, tactful, encouraging, or persuasive. It is simply trying to solve the problem.

That is the voice we came for.