Reasoning
Overview
Reasoning models like OpenAI GPT-5, Claude 4 and 5, and Gemini 3 have some additional options that can be used to tailor their behaviour. They also in some cases make available full or summarized reasoning traces for the chains of thought that led to their response.
Reasoning Effort
The reasoning_effort option controls how much reasoning is performed. Inspect supports a supserset of what the various provider APIs accept and does mapping as required (as documented below). Available options include: none, minimal, low, medium, high, xhigh, and max.
For example:
inspect eval math.py --model openai/gpt-5 --reasoning-effort highOr from Python:
eval("math.py", model="openai/gpt-5", reasoning_effort="high")Provider Mapping
OpenAI
| Inspect input | API value |
|---|---|
none |
reasoning omitted |
minimal / low / medium / high / xhigh |
identical |
max |
max on GPT-5.6+; xhigh on earlier models |
GPT-5.5 and later reason at the server default effort when reasoning_effort is not set, and in that state the API rejects temperature, top_p, and logprobs. Inspect drops those options with a warning; pass reasoning_effort="none" to disable reasoning and have them sent.
GPT-6 Sol and GPT-6 Luna accept none and low through max (the API rejects minimal) and follow the GPT-5.5+ rules above (they reason at medium unless reasoning_effort is set). GPT-6 Astra always reasons: it accepts low through max only, and the API rejects none and minimal with an error. It also rejects temperature, top_p, and logprobs regardless of effort, so Inspect drops those options with a warning for Astra.
Note that GPT-5.6 models treat reasoning_effort as a ceiling rather than a floor: on prompts the model judges easy it may perform no reasoning at all (producing zero reasoning tokens), even at higher effort levels.
Anthropic Claude 4.6+ and Claude 5
Opus 4.6, Opus 4.7, Opus 4.8, Sonnet 4.6, and the Claude 5 models all use adaptive thinking with the effort parameter. When reasoning_effort is not set, Opus 4.6/4.7 and Sonnet 4.6 let the model auto-select effort, while Opus 4.8, Sonnet 5, Opus 5, and Fable/Mythos 5.x default to high server-side and Opus 5.5 defaults to medium.
For Fable/Mythos 5.x and Opus 5.5 thinking is always on and cannot be disabled: passing none does not turn reasoning off — Inspect omits the thinking field and the model reasons at the configured effort (or the server-side default if none is set). Sonnet 5 and Opus 5 do accept none and disable thinking (Opus 5 only at effort high or below).
| Inspect input | API value |
|---|---|
none |
omitted (off by default) on Opus 4.6/Sonnet 4.6; disabled on Opus 4.7/4.8, Sonnet 5, Opus 5; omitted (still on) for Fable/Mythos 5.x and Opus 5.5 |
minimal / low |
low |
medium |
medium |
high |
high |
xhigh |
xhigh on Claude 4.7+ and Claude 5; otherwise high |
max |
max |
Anthropic Claude 3.7 / 4.0 / 4.1 / 4.5
These models do not accept effort natively, so Inspect automatically bridges reasoning_effort to an extended thinking token budget as follows:
| Effort | Token budget |
|---|---|
minimal |
2,048 |
low |
4,096 |
medium |
10,000 |
high |
16,000 |
xhigh / max |
32,000 |
Note that you can also pass reasoning_tokens explicitly for these models.
Google Gemini 3
Gemini 3 Flash 3.0–3.6 and Flash-Lite 3.1–3.5 expose four thinking levels (MINIMAL, LOW, MEDIUM, HIGH). Gemini 3 Pro / Pro 3.1 and Gemini 3.7 Flash and later omit MINIMAL (the API rejects it), so Inspect maps minimal to LOW there and logs a warning. The same fail-safe applies to names without a version (rolling aliases such as gemini-flash-latest, predeployment codenames) and to versions newer than those listed, until Inspect has confirmed they accept MINIMAL.
| Inspect input | API value (Flash ≤ 3.6, Flash-Lite ≤ 3.5) | API value (other Gemini 3) |
|---|---|---|
none |
thinking disabled | thinking disabled |
minimal |
MINIMAL |
LOW |
low |
LOW |
LOW |
medium |
MEDIUM |
MEDIUM |
high / xhigh / max |
HIGH |
HIGH |
Google Gemini 2.5
Does not accept effort levels, rather they support a thinking_budget. Inspect bridges reasoning_effort to the following budgets:
| Effort | Token budget |
|---|---|
minimal |
2,048 |
low |
4,096 |
medium |
10,000 |
high |
16,000 |
xhigh / max |
32,000 |
Note that you can also pass reasoning_tokens explicitly for these models.
Grok
Grok 3 Mini and Grok 4.X variants (grok-4-fast-reasoning, grok-4.1-fast-reasoning, grok-4.20, grok-4.3, grok-4.5, grok-4.6, grok-4.7) accept reasoning_effort. The original grok-4 reasons but does not accept the parameter — Inspect omits effort for that model. Note that Grok 4.5, 4.6 and 4.7 default to high effort and their reasoning cannot be disabled. Inspect maps reasoning_effort as follows:
| Inspect input | API value |
|---|---|
none |
reasoning omitted |
minimal / low |
low |
medium |
medium |
high |
high |
xhigh / max |
xhigh |
xhigh is a real effort level from grok-4.6 onward (for grok-4.20-multi-agent it controls how many agents collaborate); xAI documents that Grok 4.X models without xhigh support (e.g. grok-4.5) treat it as high, so Inspect passes it through and lets the service downgrade. Grok 3 Mini documents only low/high, so xhigh and max clamp to high there. Sending xhigh requires xai_sdk >= 1.18 — on older SDK versions (whose transport cannot express values above high) Inspect clamps xhigh and max to high for all models.
DeepSeek
DeepSeek models (deepseek-flash and deepseek-v4-pro) think by default (at high effort) and document a three-level effort scale of low / high / max. Inspect maps reasoning_effort as follows:
| Inspect input | API value |
|---|---|
none |
thinking disabled |
minimal / low |
low |
medium / high |
high |
xhigh / max |
max |
DeepSeek’s own server-side mapping treats a raw xhigh as high; Inspect sends max for xhigh so the top of Inspect’s scale reaches the top of DeepSeek’s. Note that deepseek-v4-pro currently runs low effort requests at high effort server-side (DeepSeek has indicated this will change in a future update).
Mistral
Mistral reasoning models (Mistral Medium 3.5+ and Mistral Small 4+) accept a two-level scale: high (emit a thinking chunk before the answer) and none. Thinking is off by default — set reasoning_effort to turn it on. Inspect maps reasoning_effort as follows:
| Inspect input | API value |
|---|---|
none |
none |
minimal / low / medium / high / xhigh / max |
high |
Non-reasoning Mistral models reject the parameter, and Inspect omits it when reasoning_effort is not set. (The earlier Magistral models, which thought unconditionally, were retired from the API in 2026 — requests for them are redirected to Mistral Medium 3.5 / Mistral Small 4.)
OpenRouter
Passes through to the underlying model; OpenRouter itself maps effort to budget_tokens for models that need it, using the formula budget = clamp(max_tokens × ratio, 1024, 128000).
| Input | API value | Ratio |
|---|---|---|
none |
reasoning omitted | — |
minimal |
minimal |
0.1 |
low |
low |
0.2 |
medium |
medium |
0.5 |
high |
high |
0.8 |
max / xhigh |
xhigh |
0.95 |
LiteLLM Proxy
Sends the requested value, which LiteLLM maps to the upstream provider’s parameter (e.g. adaptive thinking with output_config.effort for Claude). When LiteLLM or the upstream model rejects the value, Inspect retries with the strongest effort the model accepts at or below it (otherwise the weakest above it), or with no effort if the model takes none, and warns once. LiteLLM decides which values a model takes from its model map, so for models it doesn’t know set base_model in the proxy config (see LiteLLM Proxy).
Groq / Ollama / SageMaker / SambaNova
Upstream APIs accept only low / medium / high. Inspect clamps the extended values. none is not a supported value, so it is omitted and the provider/model default applies — this does not disable reasoning (always-on models keep reasoning):
| Inspect input | API value |
|---|---|
none |
omitted (provider/model default) |
minimal / low |
low |
medium |
medium |
high / xhigh / max |
high |
Together
Together accepts low / medium / high for all reasoning models, and additionally xhigh / max on some (e.g. DeepSeek V4 Pro); only gpt-oss rejects the top-end values. minimal is never accepted. none is not a supported effort value, so it is omitted and the provider/model default applies — to turn reasoning off on hybrid models, pass reasoning={"enabled": false} rather than an effort value.
| Inspect input | API value (gpt-oss) | API value (other models) |
|---|---|---|
none |
omitted (provider/model default) | omitted (provider/model default) |
minimal |
low |
low |
low / medium / high |
identical | identical |
xhigh / max |
high |
identical |
Perplexity
Accepts minimal in addition to low / medium / high, so Inspect keeps minimal and clamps only the top-end values. none is not a supported value, so it is omitted and the provider/model default applies (reasoning is not disabled):
| Inspect input | API value |
|---|---|
none |
omitted (provider/model default) |
minimal |
minimal |
low |
low |
medium |
medium |
high / xhigh / max |
high |
Fireworks
Effort validity is model-dependent. No Fireworks model accepts minimal (→ low). gpt-oss and MiniMax M2 accept only low / medium / high: they reject none (omitted, so the provider/model default applies) and xhigh / max (→ high). Other reasoning models — DeepSeek, GLM, Kimi, and MiniMax M3 — accept none and xhigh / max, so those pass through:
| Inspect input | API value (gpt-oss / MiniMax M2) | API value (other models) |
|---|---|---|
none |
omitted (provider/model default) | none |
minimal |
low |
low |
low / medium / high |
identical | identical |
xhigh / max |
high |
identical |
Bedrock
Varies by hosted model family. Claude on Bedrock accepts only reasoning_tokens (no effort); Nova uses its own reasoningConfig.maxReasoningEffort scale; GPT-OSS passes effort through.
Model Defaults
When Inspect does not pass reasoning_effort, each provider applies its own default. The table below records the documented provider default per model. Models with no entry have either no documented default or no effort scale at all.
| Model | Default effort |
|---|---|
| anthropic/claude-fable-5 | high |
| anthropic/claude-fable-5-1 | high |
| anthropic/claude-mythos-5 | high |
| anthropic/claude-mythos-5-1 | high |
| anthropic/claude-opus-4-6 | adaptive |
| anthropic/claude-opus-4-7 | adaptive |
| anthropic/claude-opus-4-8 | high |
| anthropic/claude-opus-5 | high |
| anthropic/claude-opus-5-5 | medium |
| anthropic/claude-sonnet-4-6 | adaptive |
| anthropic/claude-sonnet-5 | high |
| deepseek/deepseek-flash | high |
| deepseek/deepseek-reasoner | no effort scale |
| deepseek/deepseek-v4-flash | high |
| deepseek/deepseek-v4-pro | high |
| fireworks/glm-5p3 | max |
| fireworks/glm-5p3-flash | max |
| google/gemini-3-flash-preview | medium |
| google/gemini-3-pro | high |
| google/gemini-3.1-flash-lite-preview | medium |
| google/gemini-3.1-pro | high |
| google/gemini-3.5-flash | medium |
| google/gemini-3.5-flash-lite | minimal |
| google/gemini-3.6-flash | medium |
| google/gemini-3.7-flash | medium |
| google/gemini-3.8-flash | medium |
| grok/grok-3-mini | low |
| grok/grok-4 | no effort scale |
| grok/grok-4.3 | low |
| grok/grok-4.5 | high |
| grok/grok-4.6 | high |
| grok/grok-4.7 | high |
| mistral/magistral-medium-2506 | no effort scale |
| mistral/magistral-small-2506 | no effort scale |
| mistral/mistral-medium-2604 | none |
| mistral/mistral-small-2603 | none |
| moonshotai/kimi-k3 | max |
| openai/gpt-5 | medium |
| openai/gpt-5-mini | medium |
| openai/gpt-5-nano | medium |
| openai/gpt-5.1 | medium |
| openai/gpt-5.1-codex | medium |
| openai/gpt-5.2 | medium |
| openai/gpt-5.2-codex | medium |
| openai/gpt-5.2-pro | high |
| openai/gpt-5.3-codex | medium |
| openai/gpt-5.4 | medium |
| openai/gpt-5.4-mini | medium |
| openai/gpt-5.4-nano | medium |
| openai/gpt-5.4-pro | high |
| openai/gpt-5.5 | medium |
| openai/gpt-5.5-pro | high |
| openai/gpt-5.6 | medium |
| openai/gpt-5.6-luna | medium |
| openai/gpt-5.6-sol | medium |
| openai/gpt-5.6-terra | medium |
| openai/gpt-6-astra | medium |
| openai/gpt-6-luna | medium |
| openai/gpt-6-sol | medium |
| z-ai/glm-5.3 | max |
| z-ai/glm-5.3-flash | max |
| zai-org/GLM-5.3-FP8 | max |
| zai-org/GLM-5.3-FP8-Lora | max |
| zai-org/glm-5.3 | max |
| zai-org/glm-5.3-flash | max |
Reasoning Mode
OpenAI GPT-5.6+ models support pro mode, which performs more model work for greater reliability on difficult tasks, at higher latency and token usage (billed at standard token rates). Enable it with the reasoning_mode option:
inspect eval math.py --model openai/gpt-5.6 --reasoning-mode proOr from Python:
eval("math.py", model="openai/gpt-5.6", reasoning_mode="pro")Reasoning mode is independent of reasoning_effort — effort controls how much reasoning occurs within the selected mode.
Since pro mode requests can run for several minutes, Inspect enables background processing by default when reasoning_mode="pro" (as it does for the gpt-5-pro model line); pass -M background=false to override.
Inspect passes reasoning_mode through to the API for any OpenAI model: models that can’t honor it (those prior to GPT-5.6, other than the -pro model line which accepts the redundant "pro") reject the request with an error naming the parameter.
Reasoning Content
Many reasoning models surface their underlying chain of thought in a special “thinking” or reasoning block. Inspect normalises these into ContentReasoning blocks alongside ContentText, ContentImage, etc., and displays them in their own region in Inspect View and the terminal conversation view.
Reasoning content is captured using several heuristics: a reasoning or reasoning_content field on the assistant message, content wrapped in <think></think> tags, or explicit APIs for models that support them (e.g. Anthropic extended thinking blocks).
Some models also return reasoning_tokens usage, which is included in the standard ModelUsage object.
Reasoning Options
The following reasoning options are available from the CLI and within GenerateConfig:
| Option | Description |
|---|---|
reasoning_effort |
Constrains effort on reasoning. Accepts none, minimal, low, medium, high, xhigh, max. See Reasoning Effort for per-provider mapping. Supported by all reasoning models — Inspect automatically bridges effort to a token budget for legacy Claude (3.7–4.5) and Gemini 2.5. Default is provider-defined. |
reasoning_mode |
OpenAI GPT-5.6+ only. Accepts standard, pro. Pro mode performs more model work for greater reliability at higher latency and token usage, and enables background processing by default. See Reasoning Mode. |
reasoning_tokens |
Deprecated. Prefer reasoning_effort. Explicit token budget for reasoning. Both Anthropic (budget_tokens) and Google (thinking_budget) have deprecated this control in favour of effort-based reasoning. On Anthropic Claude 4.7+ and Claude 5 it is unsupported (those models removed the token-budget control) and raises an error — use reasoning_effort instead, which works across all Claude versions. |
reasoning_summary |
OpenAI only. Provide a summary of reasoning steps. Accepts none, concise, detailed, auto. Use auto to access the most detailed summarizer available. Some OpenAI accounts require organization verification. |
reasoning_history |
How much prior reasoning to replay in conversation history. Accepts none, all, last, auto. Use last to keep reasoning from dominating the context window. Defaults to auto. |
vLLM / SGLang
vLLM and SGLang both support reasoning outputs, but the configuration is model-specific. See the vLLM and SGLang docs for details.
For vLLM, configure the model’s reasoning parser using -M model arguments. For example, Qwen3:
inspect eval math.py --model vllm/Qwen/Qwen3-8B -M reasoning_parser=qwen3Thinking mode is model-specific and controlled separately from --reasoning-effort. For models where vLLM exposes template switches such as enable_thinking or thinking, pass them as chat-template kwargs:
inspect eval math.py --model vllm/Qwen/Qwen3-8B \
-M reasoning_parser=qwen3 \
-M default_chat_template_kwargs='{"enable_thinking": true}'To override per-request:
inspect eval math.py --model vllm/Qwen/Qwen3-8B \
-M reasoning_parser=qwen3 \
-M extra_body='{"chat_template_kwargs": {"enable_thinking": true}}'Open-weights reasoning models do not all support adjustable effort levels — in those cases --reasoning-effort is a no-op even though a reasoning parser is required for vLLM to separate reasoning from the final answer.
If the model already emits reasoning between <think></think> tags (as with R1 or via prompt engineering), Inspect captures it automatically without any vLLM or SGLang configuration.