Thinking Levels: Syntax and Options for /think Directives

What it does

• You can set the thinking level inline in any incoming request body using /t <level>, /think:<level>, or /thinking <level>.
• The available levels, with their aliases, are off | minimal | low | medium | high | xhigh | adaptive | max | ultra, which closely follow Anthropic's classic magic-word scale of "think" < "think hard" < "think harder" < "ultrathink":
  • minimal corresponds to "think"
  • low corresponds to "think hard"
  • medium corresponds to "think harder"
  • high corresponds to "ultrathink" (the maximum budget)
  • xhigh corresponds to "ultrathink+" (available on GPT-5.2+ and Codex models, plus Anthropic Claude Opus 4.7+ with effort)
  • adaptive relies on provider-managed adaptive thinking (supported on Claude 4.6 via Anthropic/Bedrock, Anthropic Claude Opus 4.7+, and Google Gemini dynamic thinking)
  • max uses the provider's maximum reasoning (Anthropic Claude Opus 4.7+; Ollama translates this to its highest native think effort)
  • ultra applies the provider's maximum reasoning and, when the chosen model or runtime allows it, adds proactive sub-agent orchestration
  • x-high, x_high, extra-high, extra high, and extra_high all resolve to xhigh.
  • highest resolves to high.
• Notes on provider behavior:
  • The thinking menus and pickers are driven by provider profiles. Each provider plugin declares the exact set of levels for the selected model, including labels like binary on.
  • adaptive, xhigh, max, and ultra appear only for provider/model/runtime profiles that actually support them. If you type a directive for an unsupported level, it gets rejected along with the valid options for that model.
  • When stored levels aren't supported, they get remapped based on provider profile rank. On non-adaptive models, adaptive drops back to medium, while xhigh and max fall back to the highest supported non-off level for the model in question.
  • For Anthropic Claude 4.6 models, adaptive is the default when no explicit thinking level is provided.
  • Anthropic Claude Opus 4.8 and Opus 4.7 leave thinking off unless you explicitly set a level. Once adaptive thinking is enabled, Opus 4.8's provider-owned effort default is high.
  • On Anthropic Claude Opus 4.7+, /think xhigh triggers adaptive thinking plus output_config.effort: "xhigh", since /think acts as a thinking directive and xhigh controls the Opus effort setting.
  • Anthropic Claude Opus 4.7+ also offers /think max, which routes to the same provider-owned max effort path.
  • Direct DeepSeek V4 models expose /think xhigh|max; both of these map to DeepSeek reasoning_effort: "max", while lower non-off levels map to high.
  • For DeepSeek V4 models routed through OpenRouter, /think xhigh is exposed, and OpenRouter-supported reasoning.effort values are sent instead of DeepSeek-native top-level reasoning_effort. Lower non-off levels map to high, and stored max overrides fall back to xhigh.
  • Ollama models with thinking capability expose /think low|medium|high|max; max maps to native think: "high" because Ollama's native API accepts low, medium, and high as effort strings.
  • OpenAI GPT models map /think through model-specific Responses API effort support. /think off sends reasoning.effort: "none" only when the target model supports it; otherwise, OpenClaw leaves out the disabled reasoning payload rather than sending an unsupported value.
  • GPT-5.6 Sol and Terra expose native /think ultra via the Codex runtime. GPT-5.6 Luna exposes levels through max because its Codex catalog doesn't advertise Ultra.
  • The embedded OpenClaw runtime exposes logical /think ultra for GPT-5.6 Sol, Terra, and Luna. It sends the provider's max effort and adds run-scoped proactive sub-agent orchestration guidance.
  • Custom OpenAI-compatible catalog entries can opt into /think xhigh by setting models.providers.<provider>.models[].compat.supportedReasoningEfforts to include "xhigh". This relies on the same compat metadata that maps outbound OpenAI reasoning effort payloads, so menus, session validation, agent CLI, and llm-task stay consistent with transport behavior.
  • Stale configured OpenRouter Hunter Alpha refs skip proxy reasoning injection because that retired route could return final answer text through reasoning fields.
  • Google Gemini maps /think adaptive to Gemini's provider-owned dynamic thinking. Gemini 3 requests omit a fixed thinkingLevel, while Gemini 2.5 requests send thinkingBudget: -1; fixed levels still map to the closest Gemini thinkingLevel or budget for that model family.
• MiniMax M2.x (minimax/MiniMax-M2*) on the Anthropic-compatible streaming path defaults to thinking: { type: "disabled" } unless you explicitly set thinking in model params or request params. This avoids leaked reasoning_content deltas from M2.x's non-native Anthropic stream format. MiniMax-M3 (and M3.x) is exempt: M3 emits proper Anthropic thinking blocks and returns empty content when thinking is disabled, so OpenClaw keeps M3 on the provider's omitted/adaptive thinking path.
• Z.AI (zai/*) is binary (on/off) for most GLM models. GLM-5.2 is the exception: it exposes /think off|low|high|max, maps low and high to Z.AI reasoning_effort: "high", and maps max to reasoning_effort: "max".
• Moonshot API Kimi K3 (moonshot/kimi-k3) always thinks at max, sends reasoning_effort: "max", omits the K2 thinking field and fixed sampling overrides, and preserves K3-supported tool choices. Kimi Code K3 (kimi/k3 and kimi/k3-256k) exposes the full /think ladder with a high default: off sends thinking.type: "disabled", minimal/low map to low effort, medium/high/adaptive to high effort, and xhigh/max to max effort. Current Kimi Code refs also include kimi/kimi-for-coding and kimi/kimi-for-coding-highspeed. Kimi K2.7 Code (moonshot/kimi-k2.7-code and moonshot/kimi-k2.7-code-highspeed) always thinks, exposes only on, and omits both outbound thinking and reasoning_effort. Other moonshot/* models map /think off to thinking: { type: "disabled" } and any non-off level to thinking: { type: "enabled" }. When K2 thinking is enabled, Moonshot only accepts tool_choice auto|none; OpenClaw normalizes incompatible values to auto.

Resolution order

1. Inline directive on the message (applies only to that message).
2. Session override (set by sending a directive-only message).
3. Per-agent default (agents.entries.*.thinkingDefault in config).
4. Global default (agents.defaults.thinkingDefault in config).
5. Fallback: provider-declared default when available; otherwise reasoning-capable models resolve to medium or the nearest supported non-off level for that model, and non-reasoning models stay off.

Setting a session default

• Transmit a message containing nothing but the directive (extra whitespace is fine), for instance /think:medium or /t high.
• This persists for the ongoing session (per-sender by default). To drop the session override and fall back to the configured or provider default, use /think default; acceptable synonyms are inherit, clear, reset, and unpin.
• An explicit off override is stored via /think off. This disables thinking until you modify or remove the session override.
• A confirmation reply is dispatched (Thinking level set to high. / Thinking disabled.). Should the level be invalid (e.g. /thinking big), the command is refused with a suggestion, and the session state remains untouched.
• To view the current thinking level, send /think (or /think:) without any argument.

Application by agent

• Embedded OpenClaw: the resolved level is handed to the in-process OpenClaw agent runtime.
• Claude CLI backend: concrete non-off levels are forwarded to Claude Code as --effort when claude-cli is in use; adaptive strips configured effort flags and lets Claude Code's environment, settings, and model defaults determine effective effort. Refer to CLI backends.

Fast mode (/fast)

• Levels: auto|on|off|default.
• A directive-only message toggles a session fast-mode override and responds with Fast mode set to auto., Fast mode enabled., or Fast mode disabled.. To clear the session override and revert to the configured default, use /fast default; aliases include inherit, clear, reset, and unpin.
• Send /fast (or /fast status) with no mode to check the current effective fast-mode state.
• OpenClaw determines fast mode in this sequence:
  1. Inline/directive-only /fast auto|on|off override (/fast default clears this layer)
  2. Session override
  3. Per-agent default (agents.entries.*.fastModeDefault)
  4. Per-model config: agents.defaults.models["<provider>/<model>"].params.fastMode
  5. Fallback: off
• With auto, the session/config mode stays auto, but each new model call is resolved independently. Calls initiated before the auto cutoff have fast mode enabled; later retry, fallback, tool-result, or continuation calls start with fast mode disabled. The cutoff defaults to 60 seconds; adjust agents.defaults.models["<provider>/<model>"].params.fastAutoOnSeconds on the active model to change it.
• For openai/*, fast mode corresponds to OpenAI priority processing by transmitting service_tier=priority on supported Responses requests.
• For Codex-backed openai/* / openai-codex/* models, fast mode sends the identical service_tier=priority flag on Codex Responses. Native Codex app-server turns receive the tier only on turn/start or thread start/resume, so auto cannot retier an already-running app-server turn; it applies to the next model turn OpenClaw starts.
• For direct public anthropic/* requests, including OAuth-authenticated traffic sent to api.anthropic.com, fast mode corresponds to Anthropic service tiers: /fast on sets service_tier=auto, /fast off sets service_tier=standard_only.
• For minimax/* on the Anthropic-compatible path, /fast on (or params.fastMode: true) rewrites MiniMax-M2.7 to MiniMax-M2.7-highspeed.
• Explicit Anthropic serviceTier / service_tier model params override the fast-mode default when both are set. OpenClaw still skips Anthropic service-tier injection for non-Anthropic proxy base URLs.
• /status displays Fast when fast mode is enabled and Fast:auto when the configured mode is auto.

Verbose directives (/verbose or /v)

• Levels: on (minimal) | full | off (default).
• A directive-only message flips the session verbose setting and answers with Verbose logging enabled. / Verbose logging disabled.; bad levels trigger a hint and leave the state untouched.
• /verbose off saves an explicit session override; remove it through the Sessions UI by picking inherit.
• Authorized external channel senders can keep the session verbose override. Internal gateway/webchat clients require operator.admin to do the same.
• An inline directive only touches that single message; otherwise session/global defaults apply.
• Running /verbose (or /verbose:) without arguments displays the current verbose level.
• With verbose on, agents emitting structured tool results relay each tool call as its own metadata-only message, tagged with <emoji> <tool-name>: <arg> when present. These summaries appear the moment each tool starts (separate bubbles), not as streaming deltas.
• Tool failure summaries show up in normal mode, but raw error detail suffixes stay hidden unless verbose is full.
• When verbose is full, tool outputs also get forwarded after finishing (separate bubble, clipped to a safe size). Flipping /verbose on|full|off mid-run makes subsequent tool bubbles respect the new value.
• agents.defaults.toolProgressDetail dictates the format of /verbose tool summaries and progress-draft tool lines. Pick "explain" (default) for short human labels like 🛠️ Exec: checking JS syntax; choose "raw" when you want the raw command/detail appended for debugging. Per-agent agents.entries.*.toolProgressDetail overrides the default.
  • explain: 🛠️ Exec: check JS syntax for /tmp/app.js
  • raw: 🛠️ Exec: check JS syntax for /tmp/app.js, node --check /tmp/app.js

Plugin trace directives (/trace)

• Levels: on | off (default).
• A directive-only message toggles session plugin trace output and responds with Plugin trace enabled. / Plugin trace disabled..
• An inline directive only affects that message; session/global defaults apply otherwise.
• Sending /trace (or /trace:) with no argument reveals the current trace level.
• /trace is more limited than /verbose: it only surfaces plugin-owned trace/debug lines, such as Active Memory debug summaries.
• Trace lines can appear in /status and as a follow-up diagnostic message after the normal assistant reply.

Reasoning visibility (/reasoning)

• Levels: on|off|stream.
• A directive-only message toggles whether thinking blocks appear in replies.
• When on, reasoning is delivered as a separate message prefixed with Thinking.
• stream: streams reasoning while the reply is generating when the active channel supports reasoning previews, then sends the final answer without reasoning.
• Alias: /reason.
• Running /reasoning (or /reasoning:) without arguments shows the current reasoning level.
• Resolution order: inline directive, then session override, then per-agent default (agents.entries.*.reasoningDefault), then global default (agents.defaults.reasoningDefault), then fallback (off).

Malformed local-model reasoning tags get handled conservatively. Closed <think>...</think> blocks stay hidden on normal replies, and unclosed reasoning after already visible text is also hidden. If a reply is fully wrapped in a single unclosed opening tag and would otherwise deliver as empty text, OpenClaw removes the malformed opening tag and delivers the remaining text.

Related

• Elevated mode docs live in Elevated mode.

Heartbeats

• Heartbeat probe body is the configured heartbeat prompt (default: Follow the heartbeat monitor scratch context when provided. Recurring tasks are automations; create or change their schedules with the automations tool, not heartbeat scratch. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK.). Inline directives in a heartbeat message apply as usual (but avoid changing session defaults from heartbeats).
• Heartbeat delivery uses the last outbound-capable non-reasoning payload. Separate reasoning or Thinking payloads remain internal, and a reasoning-only heartbeat result produces no alert.

Web chat UI

• When the page loads, the web chat thinking selector reflects the level already stored for the session, pulled from the inbound session store or configuration.
• Choosing a different level immediately writes the session override through sessions.patch; this happens without waiting for the next message send, and it is not a one-time thinkingOnce override.
• If a send occurs while model, reasoning, or speed picker adjustments are still pending, it waits for all outstanding picker patches; should any patch fail, the message is held back for manual review.
• The first entry always represents the clear-override action. It displays Inherited: <resolved level>, and Inherited: Off appears when inherited thinking is turned off.
• Explicit picker selections show their direct level labels, but provider labels are preserved where they exist (for instance, Maximum for a provider-labeled max option).
• The picker relies on thinkingLevels from the gateway session row or defaults, with thinkingOptions retained as a legacy label list. The browser UI does not maintain its own provider regex list; model-specific level sets belong to plugins.
• /think:<level> continues to function and modifies the same stored session level, keeping chat directives and the picker consistent with each other.

Provider profiles

• Provider plugins can offer resolveThinkingProfile(ctx) to specify the model's supported levels and its default.
• Provider plugins that proxy Claude models should reuse resolveClaudeThinkingProfile(modelId) from openclaw/plugin-sdk/provider-model-shared so direct Anthropic and proxy catalogs remain consistent.
• Each profile level stores a canonical id (off, minimal, low, medium, high, xhigh, adaptive, max, or ultra) and may include a display label. Binary providers use { id: "low", label: "on" }.
• Profile hooks receive merged catalog facts when those are available, including reasoning, compat.thinkingFormat, and compat.supportedReasoningEfforts. Only expose binary or custom profiles with those facts when the configured request contract supports the corresponding payload.
• Tool plugins validating an explicit thinking override should use api.runtime.agent.resolveThinkingPolicy({ provider, model, agentRuntime }) plus api.runtime.agent.normalizeThinkingLevel(...); they must avoid maintaining their own provider or model level lists. Pass agentRuntime when the tool controls the execution path, such as in an always-embedded run.
• Tool plugins with access to configured custom model metadata can pass catalog into resolveThinkingPolicy so compat.supportedReasoningEfforts opt-ins are reflected in plugin-side validation.
• Published legacy hooks (supportsXHighThinking, isBinaryThinking, and resolveDefaultThinkingLevel) remain as compatibility adapters, but new custom level sets should use resolveThinkingProfile.
• Gateway rows and defaults expose thinkingLevels, thinkingOptions, and thinkingDefault so ACP and chat clients render the same profile ids and labels that runtime validation uses.