Deep Dive

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:

1

/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.

2

/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:

LevelWhat It MeansDeepSeek V4OpenAI 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

Reply: "Thinking level set to 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?

The directive is stripped before the model sees your message.

Check Current Level

Send the directive with no argument:

/think

Reply: "Current thinking level: high."

To clear a session override and go back to the configured default:

/think default

Aliases: inherit, clear, reset, unpin all work the same way.

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

ModelBest ForContext WindowMax Output
deepseek/deepseek-v4-flashFast, everyday tasks. Default choice.1,000,000384,000
deepseek/deepseek-v4-proComplex analysis, higher-stakes work.1,000,000384,000
deepseek/deepseek-chatV3.2 non-thinking surface. Smaller window.131,0728,192
deepseek/deepseek-reasonerV3.2 reasoning-enabled. Legacy surface.131,07265,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 LevelOpenAI EffortWhen to Use
/think offreasoning.effort: "none"Quick responses, simple questions.
/think minimalreasoning.effort: "minimal"Basic fact checks, light classification.
/think lowreasoning.effort: "low"Straightforward analysis, summaries.
/think mediumreasoning.effort: "medium"Multi-step reasoning, comparisons. (Default)
/think highreasoning.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:

SettingBehavior
/reasoning offThinking is hidden. You only see the final answer. (Default)
/reasoning onThinking blocks appear as a separate message before the answer, labeled "Thinking".
/reasoning streamThinking 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.

This is what Pam runs for most sessions.

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.

Note: turn /reasoning off when done — it adds latency to every reply.

How OpenClaw Decides Your Thinking Level

When you send a message, OpenClaw resolves your thinking level in this order:

1

Inline directive on your message (e.g. /think xhigh inside a regular message). Applies only to that message.

2

Session override set by sending a directive-only message (e.g. just /think high). Persists for the whole session.

3

Per-agent default configured in agents.list[].thinkingDefault. Set this in openclaw.json for a specific agent.

4

Global default configured in agents.defaults.thinkingDefault. Applies to all agents unless overridden.

5

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"
    }
  }
}

This sets /think medium as the starting level for all agents, with reasoning visibility off.

Bonus: Fast Mode (/fast)

Separate from thinking depth, /fast controls processing priority — not reasoning effort:

SettingOpenAI BehaviorAnthropic Behavior
/fast onSends service_tier=prioritySends service_tier=auto
/fast offDefault processing speedSends service_tier=standard_only
/fast autoFast for first 60s, then normalSame 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

Does higher thinking always give better answers?

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.

Does /think affect token usage and cost?

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.

Can I use /think with any model?

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.

What's the difference between /think and /reasoning?

/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.

Does DeepSeek V4 work differently with thinking and tools?

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.

What happens if I set an unsupported level?

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.

Read the Lesson

Using Slash Commands

A complete reference for /think, /model, /fast, /status, and other OpenClaw commands.

Read the Guide

Give Your Ally Better Context

How to provide the right background so your Ally produces useful work.

Read the Lesson