OpenClaw Thinking Mode Explained: When to Turn It On, Off, and Why It Matters

Nine thinking levels. Different defaults per model. A bill that moves with every level you pick. Here's the reference, checked against the OpenClaw docs for v2026.9.6.

A user in the OpenClaw Discord was confused about thinking mode. His agent used Claude Sonnet and suddenly felt "more thoughtful" on hard tasks but slower on simple ones. He hadn't changed any settings.

He didn't have to. OpenClaw v2026.3.1 made adaptive the default thinking level for Claude 4.6 models, and the changelog line was the only notice he got.

His simple FAQ bot was now pausing to reason before answering "What are your business hours?" That pause cost tokens. Those tokens cost money. He didn't know why.

The same thing keeps happening with every new model generation. Claude Sonnet 5 ships with adaptive thinking at high effort. Claude Opus 5.5 always thinks, and /think off can't switch that off. Update OpenClaw, and the default under your agent can quietly change.

This is the reference post for OpenClaw thinking mode. What the nine levels are, how they differ across providers, what they cost, and when to turn each one on or off.

What thinking mode actually does (the 30-second version)

Thinking mode controls how much the model reasons before responding. When enabled, the model generates an internal reasoning chain (thinking tokens) before producing the visible response. You pay for thinking tokens. The user doesn't see them by default.

More thinking = better accuracy on complex tasks (multi-step reasoning, coding, research). More thinking = wasted time and money on simple tasks (FAQ, greetings, scheduling).

The nine levels: off, minimal, low, medium, high, xhigh, adaptive, max, and ultra (added in v2026.9.2).

You set them with an inline directive: /think <level>, /think:<level>, /thinking <level>, or the short form /t <level>. Send /think on its own to see the current level, and /think default to clear a session override.

The hierarchy (highest priority first): inline directive on the message > session override > per-agent thinkingDefault > per-agent model default > shared model default > global thinkingDefault > provider fallback.

That means you can set a global default of "low," override a specific agent to "high," and still push individual messages to "max" with /think max inline.

The key insight: Thinking mode is not on/off. It's a spectrum. The right level depends on the task, the model, and whether you're willing to trade speed and cost for accuracy. Most agents should run at "low" or "medium," not "high" or "max."

The nine levels (and what each one actually does)

• off: No reasoning. Fastest response. Cheapest. Use for heartbeats, simple Q&A, FAQ bots, and any task where the answer is straightforward. Some models can't turn thinking off (more on that below), so check what off actually maps to on yours.
• minimal / low: Light reasoning. Slightly slower. Slightly more expensive. The sweet spot for conversational agents handling routine tasks with occasional complexity.
• medium: Moderate reasoning. Noticeably slower on simple tasks. Better on multi-step instructions. This is now the fallback for reasoning-capable models that don't declare their own default, and the default OpenClaw picks for Claude Opus 5.5.
• high: Heavy reasoning. The model pauses visibly. Good for research, analysis, and coding tasks. Expensive on long conversations.
• xhigh / max: The top of the reasoning budget. Use only for the hardest tasks (multi-step research, complex debugging, financial analysis). Both are offered only on models that support them, and each provider maps them differently (see the provider section below).
• adaptive: Provider-managed thinking. The model decides how much to think based on task complexity. Supported for Claude 4.6, Claude Opus 4.7 and later, and Gemini's dynamic thinking.
• ultra: New in v2026.9.2, and different from the rest. It isn't a bigger reasoning budget. It's a harness mode: OpenClaw picks the highest native effort the model supports and adds planning, verification, and (when sub-agents are available) delegation guidance for that run. Available on every model through the OpenClaw and Claude Code runtimes.

One more change worth knowing: since v2026.9.6, OpenClaw only offers the levels a model's provider profile actually declares. Type a level your model doesn't support and the directive is rejected with that model's valid options, instead of being silently accepted.

For the complete cost optimization guide, our OpenClaw cost reduction guide covers how thinking mode interacts with token costs and heartbeat routing.

The provider mess (this is where it gets confusing)

Here's what no one tells you about OpenClaw thinking mode.

Each provider maps the same /think levels differently. The same /think high command produces different behavior depending on whether you're using Anthropic, DeepSeek, Ollama, OpenAI, or OpenRouter. Here's what the current docs say.

• Anthropic, Claude Opus 5.5: Always uses adaptive thinking. OpenClaw defaults it to medium and offers low, medium, high, xhigh, and max. Stored off and minimal settings map to low, so you cannot fully switch thinking off on this model. If you need a no-thinking path, route that work to a different model.
• Anthropic, Claude Sonnet 5 and Opus 5: Adaptive thinking at high effort by default. /think off does disable it.
• Anthropic, Claude 4.6: Defaults to adaptive when no level is set (the v2026.3.1 change).
• Anthropic, Claude Opus 4.7 and 4.8: Thinking stays off unless you set a level explicitly. /think xhigh and /think max map to Anthropic's effort settings.
• DeepSeek V4 (direct): /think xhigh and /think max both map to DeepSeek's reasoning_effort: "max". Lower non-off levels map to high. Coarser than Anthropic.
• DeepSeek V4 (via OpenRouter): OpenClaw sends OpenRouter's own reasoning.effort field, and stored max overrides fall back to xhigh. This routing was the fix for the OpenRouter 400 error in GitHub issue #77350 that we covered in the DeepSeek 503 post. That issue was closed as fixed in May.
• Ollama: Thinking-capable models expose low, medium, high, and max. On local Ollama and most models, max maps to Ollama's native high. A few verified Ollama Cloud families (GLM 5.2, DeepSeek V4) send the full native effort, including max. The v2026.4.26 regression that forced thinking to false for every Ollama model (issue #73366) was closed as fixed on 28 April, so if your local agent still isn't thinking, check the model's own capability first. Running a free local model? Our guide to the best free model for OpenClaw covers which Ollama models handle thinking reliably.
• OpenAI GPT models: Mapped through each model's supported effort. On API-key routes, /think off sends reasoning.effort: "none". On subscription routes that don't support none, off doesn't guarantee zero reasoning.
• Z.AI: Binary on/off for most GLM models. GLM-5.2 and GLM-5.3 are exceptions with their own low/high/max mappings.
• Moonshot: Most models are binary (off = disabled, anything else = enabled), and when K2 thinking is on, tool_choice is limited to auto or none. Kimi K3 on the Moonshot API always thinks at max.

The provider rule: Don't assume /think high means the same thing across providers. Check what your model actually supports. OpenClaw normalizes the interface, but the backend behavior varies significantly.

The cost impact (the part that matters most)

Thinking tokens are real tokens. You pay for them as output tokens.

A rough, illustrative range: a simple question with thinking off might produce ~200-400 output tokens. The same question on high can run ~800-2,000 output tokens (the visible answer plus the thinking). On max, it can reach ~2,000-5,000+.

Put that on Claude Sonnet 5 at $10 per million output tokens. At 50 messages a day, ~300 tokens per reply with thinking off is about $4.50 a month in output. At ~3,500 tokens per reply on max, it's about $50 a month. Same agent. Same questions. Roughly 10x the output bill.

On Claude Opus 5.5 ($20 per million output tokens), double those numbers. And remember you can't drop Opus 5.5 below low, so for an agent that mostly answers simple questions, the cheaper fix is a different model, not a lower level.

On heartbeats specifically: Heartbeats run every 30 minutes by default (every hour when you're on Anthropic OAuth/token auth). If the model behind them reasons on every "check if anything needs doing" poll, you're paying reasoning tokens for the simplest possible check. Point agents.defaults.heartbeat.model at a cheap model and give that model params.thinking: "off" in agents.defaults.models. The hidden heartbeat token overhead post covers the numbers.

If managing per-agent thinking levels, provider-specific mappings, and cost implications sounds like more configuration than you want, BetterClaw handles thinking mode optimization at the platform level. The platform routes thinking levels by task type automatically. No /think commands. No provider compatibility issues. No heartbeats burning thinking tokens. Free plan with 1 agent and BYOK. $49/month for Pro with 5 agents.

The recommended config (for multi-agent setups)

For the best practices on agent configuration, our OpenClaw best practices guide covers the broader config patterns. Here's the thinking-specific recommendation. Per-agent defaults live at agents.entries.<agent>.thinkingDefault, and the global default at agents.defaults.thinkingDefault:

• Main conversational agent: thinkingDefault: "low". Fast responses for routine tasks. Users can escalate with /think high when needed.
• Reasoning/research agent: thinkingDefault: "high". Spends more time on analysis. Accepts the speed trade-off. Try /think ultra on the hard runs.
• Coding agent: thinkingDefault: "medium". Enough reasoning for code quality without the latency of high/max.
• Butler/notification agent: thinkingDefault: "off", on a model that can actually turn thinking off. Heartbeats, reminders, and notifications don't need reasoning.

If you want one model to always think a certain way no matter which agent uses it, set it on the model instead:

{
  agents: {
    defaults: {
      models: {
        "anthropic/claude-sonnet-5": {
          params: { thinking: "low" },
        },
      },
    },
  },
}

If running a single agent with mixed tasks: "low" is a safe default that doesn't waste tokens on simple tasks. On Claude 4.6, "adaptive" lets the model decide. On Opus 5.5, adaptive is always on anyway and stored adaptive resolves to medium.

Thinking vs reasoning (the confusion that costs people money)

One more thing. Thinking level and reasoning visibility are separate settings.

Thinking level (/think) controls how much the model reasons internally. This affects quality and cost.

Reasoning visibility (/reasoning, alias /reason) controls whether you see the thinking blocks. Options: on (reasoning arrives as a separate message prefixed "Thinking"), off (the default), and stream (reasoning streams as a preview on channels that support it, then the final answer arrives without it). This affects what shows up in your chat.

You can have thinking on high (model reasons deeply, you pay for it) with reasoning off (you don't see the thinking blocks). You're still paying for the thinking tokens. You just can't see them.

The common mistake: Users set /reasoning off thinking they've disabled thinking. They haven't. They've hidden the display. The model still reasons. The bill still reflects it. To actually stop the model from reasoning, use /think off, and check that your model supports it.

If you want thinking mode managed without the provider differences, per-model quirks, and display/cost confusion, give BetterClaw a try. Free plan with 1 agent and BYOK, $49/month for Pro with 5 agents. 28+ providers. Thinking optimization is automatic. No /think commands needed. The platform matches reasoning depth to task complexity. You get the quality where it matters and the speed where it doesn't.

Frequently Asked Questions

What is OpenClaw thinking mode?

Thinking mode controls how much internal reasoning the model does before producing a visible response. There are nine levels: off, minimal, low, medium, high, xhigh, adaptive, max, and ultra (a harness mode added in v2026.9.2 that adds planning and verification on top of the model's highest effort). The model generates "thinking tokens" that you pay for but don't see by default. More thinking = better on complex tasks, wasted on simple ones.

What is the default thinking level in OpenClaw?

It depends on the model. Claude 4.6 defaults to adaptive (since v2026.3.1). Claude Sonnet 5 and Opus 5 use adaptive thinking at high effort. Claude Opus 5.5 defaults to medium. Claude Opus 4.7 and 4.8 keep thinking off unless you set a level. Reasoning models without a declared default fall back to medium, and non-reasoning models stay off. An inline directive always wins, followed by the session override, the per-agent thinkingDefault, model-level params.thinking, and the global thinkingDefault.

How much does thinking mode cost in OpenClaw?

Thinking tokens bill as output tokens, so max can cost roughly 10x more per message than off on simple questions. As an illustration, 50 messages a day on Claude Sonnet 5 ($10 per million output tokens) is about $4.50 a month in output with thinking off and about $50 with thinking on max. Keep heartbeats on a cheap model with thinking off to avoid paying for reasoning on routine checks.

Why does my OpenClaw agent feel slower after updating?

A new model default is the usual cause. Claude 4.6 moved to adaptive in v2026.3.1, Sonnet 5 ships with adaptive thinking at high effort, and the fallback for other reasoning models is now medium. Simple tasks feel slower because the model reasons before answering. Fix: set thinkingDefault to "low" (or "off" where the model supports it) for agents handling mostly simple tasks, or send /think low in the session.

Does thinking mode work the same across all providers?

No. Each provider maps thinking levels differently. Opus 5.5 can't turn thinking off at all. DeepSeek maps xhigh and max to the same backend value. Local Ollama maps max to its native high. Most Z.AI and Moonshot models are binary. OpenAI subscription routes may keep reasoning even at off. OpenClaw normalizes the chat commands, but backend behavior varies, and since v2026.9.6 it only offers the levels your model declares.

Related Reading

• How to Reduce OpenClaw Costs: Thinking mode, model routing, and the other levers that move the bill
• OpenClaw DeepSeek 503 Errors: Including the OpenRouter reasoning_effort compatibility bug
• OpenClaw Model Comparison: Which models support which thinking levels reliably
• OpenClaw Best Practices: Multi-agent config patterns including thinking defaults
• OpenClaw Agent Hallucinating? 5 Fixes That Actually Work: When more thinking actually reduces hallucination, and when it doesn't