What is reasoning effort? Claude Code, Codex, Cursor and Grok

Oct 31, 2026

Reasoning effort sets how long a model thinks before it answers. The levels in Claude Code and Codex, what Cursor's plans fix, and how Grok sets effort.

Reasoning effort is how hard you ask the model to think before it answers or calls a tool. A higher level spends more tokens and more time. A lower level comes back sooner, and you review each step.

Chain-of-thought is the older name for asking a model to reason step by step before it answers. Reasoning models do a version of that on their own. Effort is the setting that scales it, when the tool exposes one.

How reasoning effort works

You pick a level for the session, or the tool picks the model’s default. On each step the model can think longer or shorter before it writes code or calls a tool. The level does not change what the tools are allowed to do. Permission modes and the sandbox still decide that.

The same word does not mean the same amount of thinking on every model. Claude Code’s docs say the scale is calibrated per model.

Reasoning effort in each tool

	Claude Code	Codex	Cursor	Grok Build
Set it	`/effort`, or `--effort`	`/model`, when the picker offers it	Not documented as a control	`/effort`
Persist it	Saved per model when you confirm with Enter	`model_reasoning_effort` in `config.toml`	Not documented	`default_reasoning_effort` under `[models]`
Levels the docs name	`low`, `medium`, `high`, `xhigh`, `max`	`low`, `medium`, `high`, `xhigh`, `max`, `ultra`	Not documented	API levels for current Grok models, below
A plan-only override	Not documented	`plan_mode_reasoning_effort`	Not documented	Not documented

Which levels a model accepts depends on the model. The table is the vocabulary in each vendor’s docs, not a promise that every model offers every word.

Claude Code

Effort controls adaptive reasoning. The model decides whether to think, and how much, based on the task. In October 2026 the model config lists low, medium, high, xhigh, and max. A model that doesn’t support the level you set falls back to the highest supported level at or below it.

The default is high on most models that support effort. Opus 5.5, Sonnet 5.5, and Haiku 5.5 default to medium. Opus 4.7 defaults to xhigh. Claude Code resolves the level in a fixed order. An environment variable named CLAUDE_CODE_EFFORT_LEVEL wins, then a level you pick in the session, then --effort, then your saved settings, then the model’s default.

/effort opens a slider. /effort high sets it directly. Confirming with Enter saves the level for that model and uses it in later sessions. max applies to the current session only, unless you set it through the environment variable. The docs describe max as the level for hard problems you want Claude to work through, and they say it can overthink, so test it before you adopt it.

ultrathink anywhere in a prompt asks for deeper reasoning on that turn without changing the saved level. Other phrases, such as “think hard”, are ordinary prompt text.

Ultracode is a separate Claude Code setting, not one of the levels. /effort ultracode turns it on. The docs say Claude then orchestrates a dynamic workflow for substantive tasks, at whatever effort level the session is using.

A skill or subagent can set effort in its frontmatter. That level applies while the skill or subagent runs, unless CLAUDE_CODE_EFFORT_LEVEL is set.

See Claude Code model configuration.

OpenAI Codex

/model chooses the active model and, when the picker offers it, the reasoning effort. The config key is model_reasoning_effort. The configuration reference describes it as the effort advertised by the selected model, and it gives low, medium, high, xhigh, max, and ultra as examples. Available levels depend on the model and the client.

plan_mode_reasoning_effort overrides the level while you are in plan mode. When that key is unset, plan mode uses its built-in preset. model_reasoning_summary is a different key. It selects how much of the reasoning summary you see, or turns summaries off, with values auto, concise, detailed, and none.

models.new_thread.model_reasoning_effort is a default for new threads. An explicit model or effort override causes both the new-thread model and the new-thread effort to be ignored.

See the Codex configuration reference and the slash commands.

Cursor

Cursor’s models and pricing page doesn’t document a command or a menu for effort. It does say what the plans fix. On Plus, Cursor’s own models run at fixed settings, and effort is medium. Choosing effort levels requires Premium or higher. Plus also leaves Fast mode off.

The page doesn’t list the level names you can choose on the higher plans. Don’t assume they match Claude Code’s or Codex’s list.

See Cursor models and pricing.

Grok Build

/effort sets reasoning effort for the current model. The settings reference also has default_reasoning_effort under [models] in ~/.grok/config.toml, described as the default effort for the default model when the model supports it. The Build docs don’t list the words /effort accepts.

The xAI API docs, checked the same day, do list levels for the Grok models people run there. For grok-4.7 and grok-4.6 the values are low, medium, high, and xhigh. high is the default. grok-4.5 stops at high, and xhigh is treated as high. Reasoning cannot be disabled. The Build command and the API parameter are documented on different pages, so this entry doesn’t claim the TUI offers every API value.

The TUI shows thinking blocks while they stream. show_thinking_blocks under [ui], or GROK_SHOW_THINKING_BLOCKS, hides them. That is display, not the effort level.

See Grok Build commands and xAI reasoning.

Details checked against each vendor’s documentation in October 2026.

A real example

You want a careful pass on a bug in a layout file, and you don’t want the deepest level for a rename later in the same afternoon. Start Claude Code at high for this session:

claude --effort high

Check the level with /effort. Drop to medium for the rename. Confirm with Enter only if you want that level saved for the model. The s key in the slider applies it to this session.

On Codex, the same idea in ~/.codex/config.toml is the documented key:

model_reasoning_effort = "high"

Use a level the selected model actually advertises. /model is where the CLI asks, when effort is available for that model. In Grok Build, run /effort and pick the level the current model offers.

When to raise or lower it

Raise it when the task has edge cases you want checked before you review, or when a wrong answer is expensive to undo. Claude Code’s own guidance puts high on bug fixes in an existing codebase, and low on a rename or a first sketch you will steer yourself.

Lower it when you are in the loop on every step. A long thinking trace fills the context window and the usage limit, and you still have to read the diff.

Plan mode can use a different level from implementation. Codex has plan_mode_reasoning_effort for that. Claude Code doesn’t document a separate plan-only effort key.

Pitfalls

Carrying one model’s level onto the next model is a bad default. Claude Code says Opus 5.5 at medium matched or beat the previous Opus at high on their coding tests, and that Opus 5.5 tends to think more per turn at a given level. Start at the new model’s default.

max on Claude Code is session-only unless the environment variable sets it, and the docs say it can show diminishing returns. A skill’s effort overrides the session level while that skill runs, which surprises you when a rename skill quietly spends a high budget.

Codex’s new-thread defaults are dropped as a pair. Override the model and the new-thread effort is ignored too, and the other way around.

Cursor Plus will not follow a higher level you copied from a Claude Code screenshot. Effort stays medium on that plan. Grok’s API default is high, and the parameter cannot turn reasoning off. Setting a penalty or a stop sequence on those reasoning models returns an error. The API page says presencePenalty, frequencyPenalty, and stop cannot be used with them.

Which AI model is best for coding? compares models on a real coding task and treats effort as part of the choice, not as a footnote.
How to use the Codex CLI shows /model asking for a reasoning effort after you pick a model.
How to use Grok Build covers /effort and starting from the default coding model.
GPT-6.1 Sol API tutorial sets reasoning effort on the OpenAI Responses API, which is the same kind of knob outside the coding-agent CLIs.

Plan mode: Plan mode makes a coding agent research and propose a plan before it edits code. How it works in Claude Code, Codex, Cursor and Grok Build, and when to use it.
Context window: The context window is everything a coding agent can see at once. How to check it, free it and keep it small in Claude Code, Codex, Cursor and Grok Build.
Sessions: A session is a saved coding-agent conversation you can resume later. How Claude Code, Codex, the Cursor CLI and Grok Build store, name, resume and fork one.

All AI glossary entries →

Follow @flaviocopes

Want me to talk about your product? You can sponsor this site.