Reasoning

Reasoning models think before they answer. Console lets you set how hard a model thinks, decide whether the thinking text reaches callers, and keeps the cost of that thinking visible in usage.

Available from the next Console release

The Model Hub Reasoning section with a default effort and the Return reasoning to callers switch, per-agent reasoning, include_reasoning, and Claude visible thinking arrive with the next Console release. Reasoning controls that were already on the model form keep working.

Three questions, answered in three places:

Question	Where you answer it
How hard may this model think by default?	The model's Reasoning section in the Model Hub
Do callers see the thinking text?	Return reasoning to callers on the model, and per call include_reasoning: false or an agent's Show reasoning
Which API does Console call upstream?	The model's Upstream API

Set a default on a model

Open Model Hub, create or edit a chat model and find Reasoning. The model page shows the effective setting under the same name.

Field	What it does
Default reasoning effort	The thinking level used for this model. Not set (provider default) sends nothing and the provider's own default applies
Thinking (toggle engines)	On or off, for engines that have no levels
Thinking budget (tokens)	Overrides the level with an exact token budget. The output cap is raised above the budget automatically
Ask for thoughts	Asks the model to emit its thinking so it can be returned
Return reasoning to callers	On by default. Off removes the thinking text from responses; the tokens are still counted and billed

Effort levels run from lowest to highest: none, minimal, low, medium, high, xhigh, max. Each model takes only some of them. For example GPT-5.x and later take none to xhigh, and Claude 5.x takes low to max. The Model Hub form offers only the levels the model takes. A level the model does not take is moved to the nearest lower level it does take (the nearest higher one when there is none lower), and a level other than none never switches thinking off.

What you can pick depends on the provider driver of the model:

Driver	Control	Values	How it is sent
openai, azure	Effort	none to max, as far as the model takes them	reasoning_effort on Chat Completions, reasoning.effort on Responses
anthropic, bedrock (Claude)	Effort and a token budget	none to max, as far as the model takes them	See Claude thinking
vertex (Gemini)	Effort and a token budget	none to max; xhigh and max use the largest budget	A thinking budget; the thoughts switch follows the budget (on whenever it is above zero)
openai-compatible, together	On or off	none (off), medium (on)	The engine only has thinking on or off
Anything else	None		The form says the provider has no reasoning controls

Which value wins

When several places name an effort for the same call, the most specific one wins. The order differs by caller, because an agent author has made a deliberate choice for the model.

A direct call to the gateway (/chat/completions, /messages):

1. The Model Hub default of the model, if set.
2. The value in the API request (reasoning_effort, or reasoning: { effort }; for /messages the thinking block).
3. Nothing: the provider's own default applies.

An agent run, per model, so the main model, an additional model and a sub-agent's model each resolve their own:

1. The agent's pick for that model (the Reasoning control beside the model in the Build tab).
2. The Model Hub default of the model that runs.
3. The API request to the agent (reasoning_effort).
4. Nothing.

Each rung is taken as a whole value, not merged field by field. A Dynamic LLM does not change this: the agent's pick outranks the Model Hub default of the model the router chose. Titles an agent generates always run with effort none. See Agent models.

Some combinations are fixed by the provider and Console follows them:

• GPT-5 family on Chat Completions. The provider rejects any reasoning effort other than none next to function tools, so a request with tools is sent with reasoning_effort: "none", whatever is configured. The model page says so when it applies. Without tools the configured effort is used.
• Claude with thinking on. Providers forbid sampling parameters such as temperature and top_p next to thinking, so Console drops them for that call.
• Models that take no effort. A caller's effort only reaches models that accept it; elsewhere it is silently left out.

Claude thinking

Claude has two thinking forms and Console picks the right one from the model id:

Models	Form
Claude 4.6 and newer (4.6, 4.7, 5.x)	Adaptive: thinking: { type: "adaptive" } and the level goes in output_config.effort (low, medium, high, xhigh or max, as far as the model takes them; minimal is sent as low; none sends no thinking)
Claude 4.5 and older	Budget: thinking: { type: "enabled", budget_tokens }. A level is turned into a token budget; the output cap is kept above the budget

Claude 5.x models return their thinking blocks empty unless the request asks for a summary. Console asks only when someone will actually see the text:

• The reasoning is visible when Return reasoning to callers is on and the caller has not hidden it (an agent with Show reasoning off, or a request with include_reasoning: false). Console then requests summarized thinking.
• When hidden, Console does not ask, so the model does not spend output tokens writing summaries nobody reads. The thinking itself still runs and is billed.
• The text is a summary of the thinking, not the raw chain of thought.

This applies to Anthropic and to Claude on Bedrock. On Bedrock, thinking is sent only for Claude models.

OpenAI reasoning summaries

OpenAI-family models do not return thinking text on Chat Completions. Reasoning summaries are a feature of the Responses API, so to get summary text for an OpenAI or Azure OpenAI model set the model's Upstream API to Responses. Clients are not affected by that choice: a Chat Completions client still gets a normal chat.completion, with the summary in message.reasoning_content.

Reasoning summaries

On the Responses upstream Console asks for a reasoning summary (reasoning.summary: "auto") whenever the text will be shown, and leaves it out when the model or the request hides reasoning, so no summary tokens are spent for nothing. The summary is returned as reasoning_content on /chat/completions (streamed as delta.reasoning_content). A model may still skip reasoning on an easy prompt at a low effort, in which case there is no summary to return.

OpenAI-compatible servers (Ollama, vLLM, LM Studio and similar) that return reasoning_content or reasoning on the message have that text passed through under the same visibility rules.

Hide reasoning from callers

There are two switches, and a request can only narrow what the model allows:

Switch	Scope	Effect
Return reasoning to callers (Model Hub, returnReasoning)	The model, for every caller	Off removes the thinking text from every response of this model
include_reasoning: false (request)	One call	Hides the text for that call. It can never show what the model hid
Show reasoning (agent)	One agent	Off leaves the text out of that agent's API responses, session messages, portal and Studio chat
reasoning.exclude (/responses)	One call	Same as include_reasoning: false

Hiding never changes accounting. The model still thinks, the provider still bills the thinking tokens, and they are still counted.

Token accounting

Reasoning tokens are a subset of the output tokens, not an addition:

• usage.completion_tokens_details.reasoning_tokens carries the count on /chat/completions when the provider reports it.
• The usage row stores it as reasoning tokens, for Anthropic, Bedrock, the Responses API and OpenAI-compatible servers that report it.
• Total output tokens already include them. Cost is computed from output tokens, so do not add reasoning tokens on top.
• A call with include_reasoning: false still shows reasoning tokens in usage; only the text is hidden.

Reasoning and the semantic cache

The semantic cache keys on reasoning visibility. A cached answer that holds thinking text is never served to a caller who asked to hide it, and the other way round. Calls with tools and agent calls bypass the cache.

Related

• Model Hub for the model form and the Upstream API
• Agent models for the reasoning control beside each agent model
• Chat completions API and Messages API for the request and response fields