You turn it off in one of three places: open the response's thinking display control and collapse or disable it, adjust extended-thinking settings before you send a prompt, or reduce reasoning effort in the interface you are using. Claude's “thinking” is a visible trace of intermediate reasoning, not a bug. Whether you can hide it outright depends on which surface you use, described below.
Claude displays its reasoning because Anthropic built extended thinking as a transparency feature, and recent interface changes expose that trace by default in more contexts. The clutter you see is the model narrating planning steps, self-checks, and dead ends before it writes the final answer. Most users can collapse, hide, or dial back that trace in the same settings panel where model choice lives.
What the thinking display actually is
Claude's visible reasoning is a stream of intermediate tokens the model generates before committing to a final answer. It is not a separate “explanation layer” bolted on afterward. The model produces these tokens the way it produces any output, then the interface decides whether to render them.
Extended thinking works by giving the model a larger internal token budget for a problem. During that phase, the model drafts candidate approaches, tests them against the question, and discards the ones that fail. When the interface shows thinking, you are watching that drafting process, including the discarded attempts. This is why it looks cluttered: dead ends are part of how the model reaches a good answer.
The important distinction is between reasoning effort and trace visibility. Reasoning effort controls how much internal work the model does. Trace visibility controls how much of that work you see. These are separate dials, and conflating them is the most common source of confusion when people try to turn the display off.
Two dials people confuse: effort versus visibility
Changing one dial does not necessarily change the other. If you lower reasoning effort, the model thinks less and the trace gets shorter, but the display may still be on. If you collapse the trace, the model still spends the same reasoning tokens and you simply stop seeing them. Your bill and latency track effort; your screen tracks visibility.
This matters because many users who say “turn it off” want the clutter gone but still want good answers. For them, the right move is collapsing the display, not slashing reasoning effort. Users who want faster, cheaper responses should lower effort, accepting that complex tasks degrade first.
A useful mental model: visibility is a window, effort is the engine. Closing the window does not slow the engine, and a smaller engine does not close the window. Treat the two settings independently and the confusion largely dissolves.
Where the control lives on each surface
The exact toggle depends on the product you use. Claude appears in a web app, desktop apps, a mobile app, a developer API, and third-party tools that wrap the API. Each renders or suppresses the thinking trace on its own terms, so instructions that work in one place may not transfer.
| Surface | Where thinking appears | Typical control | Persistence | |
|---|---|---|---|---|
| Claude web app | Expandable trace above the answer | Per-response collapse toggle; model and reasoning settings | Varies by account and rollout | |
| Claude desktop apps | Same as web | Same toggles | Mirrors web | |
| Claude mobile apps | Collapsed trace, tap to expand | Tap control; account settings | Usually collapsed by default | |
| Claude API | Thinking blocks in the response payload | Request parameter to enable or disable thinking | Per request | |
| Third-party wrappers | Depends on the wrapper | Wrapper's own setting | Wrapper-dependent |
Because Anthropic ships interface changes continuously, treat the exact label text as unstable and the location as stable. Look for the reasoning or thinking section attached to the response, and look for a model or reasoning setting near the input box. If neither exists, your account or client may not expose the feature at all.
Red flags when hunting for the control: A tutorial that names a menu item you cannot find, possibly from an older interface version. Third-party extensions that promise to “disable thinking” but only hide it visually. Settings described for a different product tier than yours. Any instruction that asks you to paste credentials or share an API key. Advice to modify the model name string, which can break requests.
Practical steps to declutter your view
Start with the cheapest fix and escalate only if it fails. Most people stop at the first or second step.
Collapse the trace on the response. Look for a disclosure arrow, a “thinking” header, or a show/hide control directly above the answer, and click it. In many interfaces the collapsed state persists for the session. Check the reasoning or thinking setting near the model selector. If reasoning effort is a slider or menu, lowering it shortens the trace and speeds responses. Start a new conversation after changing settings. Some clients apply reasoning defaults at conversation creation, so an old thread may keep the old behavior. Switch clients if the option is absent. The API and some wrappers expose explicit thinking on/off parameters that the consumer apps may not surface identically. If you only want a clean answer, ask for brevity and a final answer only. Prompt wording does not reliably suppress the trace in every client, but it reduces verbosity in the final output.
If your goal is cost or latency rather than visual clutter, prioritize step 2. If your goal is purely a clean screen, prioritize step 1. Users who do both should expect the shortest, cleanest output overall.
Why the trace persists and when it returns
Interface state is stickier than people expect. Many clients store reasoning preferences per account or per conversation type, and toggling a response-level collapse affects only that response. Change the model, and the client may reset reasoning to a default that re-expands the trace.
The trace can also reappear when a task triggers deeper reasoning. Difficult math, long documents, and multi-step coding problems often raise the model's internal effort automatically or by default setting. In those cases the display returns because the underlying reasoning returned, not because your setting was ignored.
A professional caveat worth knowing: collapsing the view does not reduce the tokens the model generated. If you are paying per token through an API, a hidden trace still bills. Visibility and cost diverge here, and finance-minded users should check usage rather than assume a tidy screen means a smaller bill.
There is also a counterintuitive detail about transparency itself. Some teams deliberately keep the trace visible because it catches errors early, and hiding it can mask a model that is confidently wrong. The clutter you dislike is, for auditors, a feature. Decide which role you are in before turning it off.
When hiding thinking can work against you
Suppressing the trace has real tradeoffs that surface differently depending on the task. The table below frames them by use case so you can decide where visibility earns its place.
| Use case | Cost of hiding trace | Cost of keeping trace | Recommended default |
|---|---|---|---|
| Quick factual lookups | None meaningful | Screen clutter | Hide |
| Debugging code | Lose the reasoning audit trail | Longer, noisier output | Keep |
| Teaching and tutoring | Students miss the worked steps | Distraction for experts | Keep, collapse by default |
| High-stakes drafting | Harder to catch bad assumptions | Slower review | Keep visible |
| High-volume API jobs | Token cost unchanged | Payload size grows | Disable thinking at request level |
| Sensitive content review | Harder to spot policy edge cases | Exposure of intermediate text | Keep, restrict access |
The pattern is consistent: hide for speed and tidiness, keep for verification and instruction. Most complaints about clutter come from the first column, and most advice to “never hide it” comes from the second. Neither camp is wrong; they are solving different problems.
One more caveat specific to shared environments. If you screen-record, screenshot, or share your screen while the trace is visible, you may expose intermediate reasoning you did not intend to publish. Collapse first when presenting.
Limitations and what the setting cannot do
The thinking toggle controls display, not capability. Turning it off will not make the model smarter or dumber on its own, and turning it on will not guarantee a better answer. Reasoning quality depends on the effort setting and the prompt, not on whether you are watching.
Exact control names, default states, and rollout timing vary by account, region, and client version, and Anthropic changes them without notice. Any specific label in this article should be read as a description of where to look, not a guaranteed menu string. If you cannot find a control, the most reliable next step is the official documentation for your specific product rather than a third-party tutorial.
Finally, no setting eliminates all verbosity. Some models restate the question or narrate steps in the final answer even with thinking hidden. For those cases, a brief instruction asking for the final answer alone helps more than any toggle.
If you are making decisions with the output, such as legal, medical, financial, or safety-related choices, keep the trace visible and review it, because hidden reasoning removes your ability to catch a flawed assumption before you act on it. This article is general educational information about interface settings, not a diagnosis, treatment plan, legal opinion, or investment recommendation, and it promises no particular outcome. Consult a qualified local professional for decisions in those areas, and contact local emergency or crisis services if you or someone else is in immediate danger.