Reasoning Settings Explained:
DeepSeek & OpenAI in OpenClaw
What /think actually does, how reasoning works in each provider, and when to use which setting.
July 8, 2026 · 9 min read · Updated for OpenClaw 2026.7.x
What Is "Reasoning" in an AI Model?
When you send a message to an AI model, the model doesn't just spit out an answer. With reasoning (also called "thinking"), the model works through the problem internally before giving you a final response. It's like the difference between someone blurting out an answer versus someone saying "let me think about this for a moment."
In OpenClaw, this internal work is normally hidden. You see only the final answer. But you can control both how much thinking the model does and whether you see it using two separate settings:
/think controls how hard the model thinks. Higher levels mean more internal reasoning before answering. This is a directive — stripped before the model sees your message.
/reasoning controls whether you see that thinking. When enabled, reasoning blocks appear as a separate message. This is about visibility, not effort.
Key insight: /think high makes the model work harder. /reasoning on lets you watch it work. You can combine them independently — think hard without watching, or watch lightweight thinking.
The Thinking Levels
OpenClaw defines a standard set of thinking levels. What each level means depends on the provider, but the names are consistent across all supported models:
| Level | What It Means | DeepSeek V4 | OpenAI GPT-5.5 |
|---|---|---|---|
| off | No reasoning. Fastest, cheapest responses. | thinking: disabled | reasoning.effort: "none" |
| minimal | Bare minimum reasoning. Quick checks. | reasoning_effort: "high" | reasoning.effort: "minimal" |
| low | Light reasoning for straightforward tasks. | reasoning_effort: "high" | reasoning.effort: "low" |
| medium | Balanced. The default for most reasoning models. | reasoning_effort: "high" | reasoning.effort: "medium" |
| high | Deep reasoning. Better for complex analysis. | reasoning_effort: "high" | reasoning.effort: "high" |
| xhigh | Maximum effort. Best results, highest cost. Not available on all models. | reasoning_effort: "max" | "ultrathink+" |
| max | Provider maximum. Maps to the strongest available effort for that model. | reasoning_effort: "max" | Provider max |
| adaptive | Let the provider decide. Available on Claude 4.6+, Gemini, and Opus 4.7+. | N/A | N/A |
Important: For DeepSeek V4, low, medium, and high all map to the same reasoning_effort: "high". Only xhigh and max trigger DeepSeek's maximum effort. If you're using DeepSeek and want the strongest reasoning, use /think xhigh.
How to Use These Settings
Thinking directives work in two ways:
As a Session Default
Send a message that contains only the directive. This sticks for your entire session:
/think high
As an Inline Hint
Include it with your regular message. It applies only to that one message:
/think xhigh Can you analyze this contract and find any red flags?
Check Current Level
Send the directive with no argument:
/think
To clear a session override and go back to the configured default:
/think default
DeepSeek V4: What's Really Happening
DeepSeek V4 models (deepseek/deepseek-v4-flash and deepseek/deepseek-v4-pro) handle reasoning differently than most providers. Here's what you need to know:
Thinking and Tool Calls
DeepSeek V4 has a stricter contract around thinking with tools. When the model thinks during a turn and then uses a tool, DeepSeek expects the assistant's internal reasoning (reasoning_content) to be included in the next request. OpenClaw handles this automatically — you don't need to do anything special for multi-turn tool use with thinking enabled.
Good news: If you switch a session from another provider to DeepSeek V4 mid-conversation, OpenClaw fills in the missing reasoning_content automatically. No need to start a fresh session.
When Thinking Is Off
When you set /think off with DeepSeek V4, OpenClaw sends thinking: { type: "disabled" } and strips any replayed reasoning_content from the conversation history. This keeps the session cleanly on the non-thinking path.
Which Model to Use
| Model | Best For | Context Window | Max Output |
|---|---|---|---|
deepseek/deepseek-v4-flash | Fast, everyday tasks. Default choice. | 1,000,000 | 384,000 |
deepseek/deepseek-v4-pro | Complex analysis, higher-stakes work. | 1,000,000 | 384,000 |
deepseek/deepseek-chat | V3.2 non-thinking surface. Smaller window. | 131,072 | 8,192 |
deepseek/deepseek-reasoner | V3.2 reasoning-enabled. Legacy surface. | 131,072 | 65,536 |
Pam's recommendation: Use deepseek/deepseek-v4-flash with /think medium for most work. Bump to /think xhigh for analysis, planning, or contract review. Use deepseek/deepseek-v4-pro when flash isn't cutting it.
OpenAI (GPT-5.5): What's Really Happening
OpenAI's GPT-5 family models support reasoning through the Responses API. Unlike DeepSeek, OpenAI offers a wider range of effort levels:
GPT-5.5 Thinking Levels
| OpenClaw Level | OpenAI Effort | When to Use |
|---|---|---|
/think off | reasoning.effort: "none" | Quick responses, simple questions. |
/think minimal | reasoning.effort: "minimal" | Basic fact checks, light classification. |
/think low | reasoning.effort: "low" | Straightforward analysis, summaries. |
/think medium | reasoning.effort: "medium" | Multi-step reasoning, comparisons. (Default) |
/think high | reasoning.effort: "high" | Complex analysis, planning, debugging. |
/think xhigh | "ultrathink+" | Hardest problems. GPT-5.2+ and Codex only. |
Note: /think off only sends reasoning.effort: "none" when the target model supports it. For models that don't accept "none", OpenClaw omits the reasoning payload instead of sending an unsupported value.
Seeing the Thinking: /reasoning
Separate from how hard the model thinks, you can control whether you see that thinking:
| Setting | Behavior |
|---|---|
/reasoning off | Thinking is hidden. You only see the final answer. (Default) |
/reasoning on | Thinking blocks appear as a separate message before the answer, labeled "Thinking". |
/reasoning stream | Thinking streams in real-time while the model works, then the final answer appears without the thinking. (Requires channel support.) |
Practical tip: Turn /reasoning on when you're debugging why an answer went wrong. Turn it off for normal use — it adds tokens and latency to the visible reply.
Which Setting Should You Use?
Here's a quick decision guide. Click your scenario:
For speed and low cost
DeepSeek: /think off on deepseek-v4-flash
OpenAI: /think off on gpt-5.4-mini
Best for: simple questions, quick lookups, formatting, basic drafts. The model answers immediately without spending tokens on internal reasoning.
For everyday work
DeepSeek: /think medium on deepseek-v4-flash
OpenAI: /think medium on gpt-5.5
Best for: emails, research summaries, content drafts, most planning. This is the sweet spot — noticeably better answers than off, without the full cost of xhigh.
For complex analysis
DeepSeek: /think xhigh on deepseek-v4-pro
OpenAI: /think xhigh on gpt-5.5
Best for: contract review, system architecture, multi-step debugging, strategic planning. Maximum reasoning budget. Highest cost, but best results for hard problems.
For understanding what went wrong
DeepSeek: /think high + /reasoning on
OpenAI: /think high + /reasoning on
Best for: when an AI answer seems off and you need to see how the model arrived at it. The reasoning trace shows assumptions, skipped steps, or misinterpretations.
How OpenClaw Decides Your Thinking Level
When you send a message, OpenClaw resolves your thinking level in this order:
Inline directive on your message (e.g. /think xhigh inside a regular message). Applies only to that message.
Session override set by sending a directive-only message (e.g. just /think high). Persists for the whole session.
Per-agent default configured in agents.list[].thinkingDefault. Set this in openclaw.json for a specific agent.
Global default configured in agents.defaults.thinkingDefault. Applies to all agents unless overridden.
Provider default when available. For reasoning-capable models, falls back to medium. For non-reasoning models, stays off.
Configuring Defaults (openclaw.json)
To set a permanent thinking default rather than using session overrides:
{
"agents": {
"defaults": {
"thinkingDefault": "medium",
"reasoningDefault": "off"
}
}
}
Bonus: Fast Mode (/fast)
Separate from thinking depth, /fast controls processing priority — not reasoning effort:
| Setting | OpenAI Behavior | Anthropic Behavior |
|---|---|---|
/fast on | Sends service_tier=priority | Sends service_tier=auto |
/fast off | Default processing speed | Sends service_tier=standard_only |
/fast auto | Fast for first 60s, then normal | Same as on for first 60s |
Tip: /fast on + /think off gives you the quickest possible responses. /fast auto + /think medium is a solid default for quality work without unnecessary waiting.
Common Questions
Not always. For simple tasks (formatting, quick lookups, basic drafts), extra thinking adds cost and latency without meaningful improvement. Use higher levels when the task benefits from multi-step reasoning: analysis, planning, debugging, comparisons, or any problem where the model needs to work through intermediate steps.
Yes. Thinking tokens are counted as output tokens by most providers, including DeepSeek and OpenAI. Higher thinking levels use more tokens. However, the thinking tokens are generally cheaper than the visible output tokens on some providers. Check your provider's pricing page for current rates.
No. Only reasoning-capable models support thinking. OpenClaw's provider profiles determine which levels are available for each model. If you try /think high on a model that doesn't support it, you'll get a rejection message with the valid options. Models like deepseek-chat (V3.2) don't support thinking — use deepseek-v4-flash or deepseek-reasoner instead.
/think controls effort — how hard the model works internally. /reasoning controls visibility — whether you see the model's internal work. You can have high thinking with reasoning off (model works hard, you see only the result) or low thinking with reasoning on (model thinks lightly, but you watch). They're independent settings.
Yes. DeepSeek V4 requires reasoning_content to be replayed on follow-up turns when a previous turn used thinking with tools. OpenClaw handles this automatically. If you're using the API directly (not through OpenClaw), you'd need to manage this yourself, but inside OpenClaw it's transparent.
OpenClaw validates thinking levels against the model's provider profile. If you request an unsupported level, you get a rejection message listing the valid options. Stored unsupported levels from config are remapped: adaptive falls back to medium, while xhigh and max fall back to the highest supported non-off level for that model.
Continue Learning
How to Talk to Your Ally
Learn the role, context, task, output, boundaries pattern for clear AI instructions.
Using Slash Commands
A complete reference for /think, /model, /fast, /status, and other OpenClaw commands.
Give Your Ally Better Context
How to provide the right background so your Ally produces useful work.