Skip to main content
Use reasoning effort to adjust how much work a supported model does before answering. Higher effort can increase latency and output-token cost. Omit the control to use the model’s default.
Chat Completions’ reasoning_effort and the Responses API’s reasoning.effort accept none, minimal, low, medium, high, xhigh, and max. max reaches Claude’s highest level; on a model without it, the request runs at the model’s highest level instead. The gateway translates the value for the model and the route serving it: an effort level, a reasoning-token budget, or an on/off switch. Keep enough output budget for both reasoning and the visible answer. A small budget can end in finish_reason: "length" with little or no answer text.

​
Levels a model doesn’t have

Models support different levels. When you ask for one a model doesn’t have, the gateway uses the nearest level it does have instead of rejecting the request:
  • A missing level moves to the closest supported one. xhigh on a model that tops out at high runs at high.
  • Ties go to the lower level, so a substitute never spends more than you asked for. medium on a model with only low and high runs at low.
  • none is never the substitute. Asking for some reasoning never turns reasoning off.
  • On a token-budget model, each level is a share of max_completion_tokens (or of the model’s own reasoning ceiling when you send no limit).
  • On an on/off model, every level above none means on.

​
See what a model supports

Every text model in GET /v1/models has a reasoning field, or null when the model has no reasoning control and ignores reasoning_effort:
  • kind: effort (a ladder of levels), budget (levels mapped to a thinking-token budget), or toggle (on or off only).
  • levels: the levels that make a difference on this model. Any other level moves to one of these. Show only these in a level picker.
  • off: whether none turns thinking off. When false, none moves to the lowest level or leaves the model at its default.
  • default: the level an omitted reasoning_effort means, where the model’s vendor documents it, otherwise null.
A model can be served from more than one route. The field describes what every route supports, so a level means the same thing if a request fails over. The table below is generated from the same data.

​
See what was applied

When a Chat Completions request sets reasoning_effort, or a Responses request sets reasoning.effort, the response carries an x-impossibl-reasoning header saying what the serving route actually received:
applied is one of:
  • the level sent, after moving down to one the model has;
  • none, when an off switch was sent;
  • on, for an on/off model;
  • budget:<tokens>, for a token-budget model;
  • custom, when your own providerOptions sent a value outside the levels above;
  • omitted, when nothing reached the backend and it ran at its own default.
Your own providerOptions win over the translated level, and the header reports what was actually sent. For example, reasoning_effort: "high" with providerOptions.openai.reasoningEffort: "low" reports applied=low. route names the provider that served the request. A streamed response’s headers are sent before any backend answers, so on a stream the header describes the first route tried; if the request fails over, the route that finally serves it can differ.

​
Leaving the field out

Without reasoning_effort, the model runs at its vendor’s default:
  • Anthropic documents high for every Claude that takes effort, except Claude Opus 5.5 and Claude Haiku 5.5, which default to medium.
  • OpenAI-family models publish no default here. Measured through the gateway on 2026-10-12, an omitted level behaved close to medium.
  • Other models use whatever their provider defaults to. Where the vendor documents it, the default column above says so.

​
Claude

  • Thinking text. On Chat Completions, the gateway asks Claude to return a summary of its thinking, so reasoning_content carries text rather than an empty string. On the Responses API it does so when you set reasoning.summary. To choose for yourself, send providerOptions.anthropic.thinking and the gateway keeps yours.
  • Output limit. If you send no max_completion_tokens, Claude Opus 5, Opus 5.5, Sonnet 5, Sonnet 5.5, and Haiku 5.5 get their full 128K output limit rather than a 4,096-token default. Thinking counts toward this limit.
  • Turning thinking off. none turns thinking off on Claude Opus 5, Sonnet 5, and Haiku 5.5. Claude Opus 5.5, Sonnet 5.5, Fable 5, and Fable 5.1 always think, so none leaves the field out rather than failing the request.
Send reasoning.effort and max_output_tokens instead. The level is translated for every route the same way as Chat Completions’ reasoning_effort, Claude included, and moves down to a level the model has. max is accepted too, and runs at the model’s highest level when it has no max:
When the model reasons, output starts with a reasoning item, before the message and any function_call items:
summary holds text only when you set reasoning.summary (auto, concise, or detailed); without it the item is still there, with "summary": []. On Claude, setting it is what asks the model for a summary of its thinking. Each reasoning block the model returned is one summary_text part. Some models return no reasoning text even when asked, and their item has an empty summary too. When streaming, the item arrives first, with response.reasoning_summary_part.* and response.reasoning_summary_text.* events; see streaming.The item has no encrypted_content. If you send a reasoning item back in input, the gateway accepts it and drops it; it is not passed to the model. reasoning.context is accepted for client compatibility but has no effect. Responses remains stateless; send conversation history in input.
When reported by the backend, Chat Completions includes usage.completion_tokens_details.reasoning_tokens, and the Responses API usage.output_tokens_details.reasoning_tokens, on a streamed response in response.completed or response.incomplete. It is a subset of completion_tokens (output_tokens on Responses); do not add it again when calculating usage. OpenAI-family backends report it directly. For Claude it comes from Anthropic’s own thinking-token count, which Anthropic computes by re-tokenizing the reasoning, so it can differ from the exact count by a few tokens. The field is left out, not set to zero, when a backend reports no count.Some backends return reasoning_content with the assistant message or streaming delta. Keep the complete assistant message when sending tool results back: reasoning content and opaque signatures can be required for the next turn. See tool calling.