Reasoning Models: When to Turn Thinking Up or Down

Use reasoning models when a wrong inference is more expensive than waiting for a better answer. Start at the documented default, then lower effort for routine work and raise it for difficult decisions: GPT-6.1 Sol, Claude Opus 5.5 and Gemini 4 Argon all default to medium.

The controls below were verified against the makers' live documentation on 31 October 2026. The useful distinction is between which model you choose, how much work you ask it to do, and how much output you allow it to generate. Those are separate decisions.

What Are Reasoning Models?

Reasoning models spend additional generation on working through a problem before delivering an answer. They are still large language models, or LLMs, which process and generate tokens: small units of text and other model data. The extra reasoning can help them consider alternatives, plan a sequence and solve problems with dependent steps. OpenAI's reasoning guide describes this internal work as reasoning tokens.

Think of a cartographer planning a route. A simple journey needs a quick direction. A difficult one needs scratch work: check the crossings, rule out blocked paths and reconsider the route. The customer may still receive a short instruction. The amount of work behind it differs.

For a founder, that distinction separates rewriting a customer email from deciding how to migrate a database while keeping existing customers online. Both produce text. Only the second requires sustained reasoning across interacting constraints.

Large Reasoning Models: Capability and Effort Are Separate

A larger or more capable model and a higher effort setting are different choices. Changing models changes the system doing the work; increasing effort asks the selected model to spend more work on the request. Neither choice supplies missing business facts.

Keep the model fixed when testing effort. Otherwise you cannot tell whether an improvement came from the model, the setting or both. For the basic vocabulary, see what tokens are in AI.

How Do Reasoning Models Work?

Thinking consumes generation that may never appear in the final answer. It can happen before the response and between tool calls, as the model uses a tool result to decide what to do next. Anthropic documents this as up-front and interleaved thinking in its thinking guide.

Thinking tokens are billed as output by OpenAI, Anthropic and Google for Gemini 4 Argon, including thinking you do not see.

The practical consequence is that answer length is a poor proxy for work performed. A terse recommendation can follow substantial reasoning. Higher effort generally trades additional time and generated tokens for a chance of a better result; it does not promise a fixed delay or a fixed token count.

A hard output cap is a different control. OpenAI's max_output_tokens, Claude's max_tokens and Gemini's max_output_tokens include thinking as well as the response. OpenAI and Google explicitly warn that exhausting this allowance during reasoning can leave an incomplete response with no visible answer. OpenAI output limits, Claude thinking, Gemini token limits.

Current AI Reasoning Models and Their Exact Controls

The current APIs expose different scales and different ways to disable thinking. Use the field names for the endpoint you actually call.

This is a compatibility comparison, not a quality ranking. The same word on different rows is not a common unit of computation.

OpenAI: Low Is GPT-6.1 Sol's Minimum

OpenAI GPT-6.1 Sol uses model ID gpt-6.1-sol. In a Responses request, set reasoning to {"effort":"medium"} to make the default explicit. low is its lightest supported setting; none and minimal are not valid alternatives. Tool calling requires the Responses API. GPT-6.1 Sol documentation.

OpenAI's current catalog also lists GPT-6 Astra, GPT-6.1 Terra and GPT-6 Luna with reasoning controls. Terra and Luna offer none as well as low, medium, high, xhigh and max; Astra's scale starts at low. A need to remove reasoning entirely can therefore change the model choice. OpenAI model catalog.

For a technical builder, test low on a scoped code change and raise effort when the task requires tracing interactions across the system. Specify what must stay true and how to verify the result. OpenAI recommends clear instructions and constraints rather than demanding a written chain of thought. Reasoning best practices.

The GPT-6.1 Sol setup guide covers the surrounding agent workflow. In the application, use the separate ChatGPT reasoning slider guide.

Anthropic: Claude Opus 5.5 Cannot Turn Thinking Off

Anthropic Claude Opus 5.5 uses model ID claude-opus-5-5. Omit thinking, or send thinking: {"type":"adaptive"}; both select its always-on adaptive behavior. Set output_config: {"effort":"medium"} for the default effort. Sending thinking: {"type":"disabled"} or a manual budget_tokens configuration returns a 400 error. Opus 5.5 API changes.

Claude's effort parameter affects the whole response, including explanations and tool calls. It is not simply a hidden-token budget. Lowering it can change how thoroughly an agent uses its tools as well as how long it thinks. Anthropic effort documentation.

The current featured lineup also includes Claude Fable 5.1, Claude Sonnet 5.5 and Claude Haiku 5.5, all with thinking support. Their off switches differ: Sonnet accepts thinking: {"type":"between_tools"} at low, medium or high to skip up-front thinking; Haiku accepts disabled at those levels. Do not copy an Opus configuration across the family without checking it. Current Claude models, thinking configurations.

For an unattended agent, check whether lower effort still performs the required verification. The Opus 5.5 agents and coding guide develops that deployment decision.

Google: Gemini 4 Argon Uses Levels, Not a Manual Thinking Budget

Google Gemini 4 Argon uses model ID gemini-4-argon. Google's current Interactions API takes generation_config: {"thinking_level":"medium"}. Its supported levels are low, medium and high, with medium as the default. Gemini 4 Argon guide.

If your application still uses generateContent, the REST field is generationConfig.thinkingConfig.thinkingLevel; the Python SDK uses thinking_config with thinking_level. On Argon, the old thinkingBudget field is deprecated: used alone it maps to a level with a warning, while sending it alongside thinkingLevel causes a 400 error. minimal is unsupported. Google's generateContent thinking reference.

Google also currently lists Gemini 3.8 Flash, Gemini 3.6 Flash and Gemini 3.5 Flash-Lite with thinking support. Their defaults and accepted levels differ, so “Flash” does not mean “no reasoning.” Gemini model catalog, thinking-level matrix.

For a founder evaluating Argon, start with a representative task and check the answer before raising the level. The Gemini 4 Argon explainer covers the broader adoption question.

DeepSeek: Check the Alias and the Effort Mapping

DeepSeek currently serves DeepSeek-V4.1-Flash-1017 through deepseek-flash and DeepSeek-V4-Pro-0813 through deepseek-v4-pro. Both support thinking and non-thinking modes. Those are the current model versions listed on the maker's model page.

In Chat Completions, reasoning_effort accepts none, low, high or max. Thinking is enabled at high when neither control is supplied. An explicit thinking: {"type":"enabled"} or thinking: {"type":"disabled"} takes precedence over the effort field's on/off behavior. Compatibility values are mapped: minimal becomes low, while medium and xhigh become high. DeepSeek Chat Completions reference.

That mapping matters when a gateway presents the same dropdown for every provider. Selecting medium does not create a native DeepSeek medium setting. When using tools, also preserve the returned reasoning_content as documented; dropping it from subsequent tool-enabled requests can produce a 400 error. DeepSeek thinking guide.

The DeepSeek V4 family guide covers the model-choice side. Here, the first integration check is that the control you send produces the mode you intended.

Reasoning vs Non Reasoning Models: Choose by the Task

Turn effort up when the task has interacting constraints, alternative approaches or costly reasoning mistakes. Turn it down when the transformation is clear and the result is easy to check. If essential evidence is missing, supply it before increasing effort.

For a funded founder: extracting agreed actions from a supplied meeting transcript is a candidate for lower effort. Resolving a roadmap conflict between contractual obligations, staffing and cash constraints deserves more. Include the actual constraints and ask for a recommendation with assumptions and unresolved questions. The gain you want is a better decision, not a longer memo.

For a mid-market CTO or senior operator: separate routine support classification from exception handling. A ticket with a clear category should not automatically receive the same reasoning allocation as an ambiguous case involving several conflicting policies. Evaluate the exception path carefully, and keep authorization checks in the application. A high effort setting is not permission to issue a refund or change an account.

For a solo technical builder: use the lightest setting that reliably completes a local, well-specified edit. Raise effort for an intermittent bug spanning several services, where the model must distinguish competing explanations. Supply logs and a failing test where possible. If it cannot see the failure, extra thinking may only elaborate a guess.

Who should wait: teams without a clear definition of a correct result should define one before making higher effort the production default. Teams whose existing low-latency workflow already passes its checks can keep it and evaluate exceptions separately.

What Is Overhyped About Thinking?

More thinking does not guarantee a correct answer, and it cannot substitute for a source the model has not received. A model can produce an elaborate justification around a mistaken premise. Check the evidence, calculations or resulting artifact independently.

A visible thinking summary is also not a complete audit trail. Anthropic explicitly describes its displayed thinking as a summary rather than the raw reasoning; Google exposes thought summaries and signatures through its API. Judge the final answer and verifiable actions, not the apparent sophistication of a thought display. Claude thinking output, Gemini thinking output.

Finally, high is not a portable performance grade. The table shows different scales, defaults and restrictions, and DeepSeek explicitly remaps several labels. Comparing providers at identically named effort levels does not establish that they spent equal time or compute.

A request for a concise answer is still useful. It constrains the deliverable. It should not be mistaken for disabling the work that precedes it.

Best Reasoning Models: Find Your Lowest Passing Setting

The best setting is the least expensive one that produces an acceptable result reliably within your waiting time. Compare models on the same task and evidence, then tune effort within each model. The broader current AI model comparison helps frame the model choice; your workload decides the setting.

1. 1

   Define what passing means

   Choose a recurring task with an outcome you can check: a code change passes its regression tests, an extraction matches the supplied record, or a recommendation respects every stated constraint. Include difficult examples, not just the easiest happy path.

2. 2

   Compare effort with everything else held steady

   Keep the prompt, evidence, tools and output allowance unchanged. Compare the documented default with the next lower and higher supported settings. For consequential work, repeat cases so one lucky answer does not decide the configuration.

3. 3

   Measure the completed task

   Record success, total elapsed time, generated tokens and any retries or manual correction. OpenAI exposes usage.output_tokens_details.reasoning_tokens; Gemini Interactions exposes usage.total_thought_tokens. Read usage fields according to each API rather than assuming all providers account for them identically. OpenAI usage, Gemini usage.

4. 4

   Keep escalation specific

   Retain the lowest setting that passes. Route known difficult cases upward and review failures before retrying: missing evidence needs evidence, while a hard inference may benefit from more effort. Do not escalate every request because one complex example improved.

The Monday move: take a recurring workflow that currently runs at a single effort level, define its acceptance check and compare settings on saved examples. Change the default only when the complete results justify it. If nothing improves, keep the simpler configuration.

Frequently Asked Questions

What are the 7 types of reasoning?

That question concerns classifications of reasoning, such as deduction and induction. It is separate from model configuration: the major APIs do not share a universal seven-level reasoning scale. Use the supported settings for the specific model and endpoint.

How does AI reasoning work?

A reasoning model generates intermediate thinking to work through a problem before answering, and can continue reasoning between tool calls. That extra work can improve a difficult result but adds generation and waiting time.

What are the 5 main AI models?

There is no fixed five-model standard. Five current examples covered here are GPT-6.1 Sol, Claude Opus 5.5, Gemini 4 Argon, DeepSeek-V4.1-Flash-1017 and DeepSeek-V4-Pro-0813. Their makers document different controls, so choose by the task rather than the count.

Which GPT is best for reasoning?

OpenAI positions GPT-6 Astra as its most capable model and GPT-6.1 Sol as a balance of capability and cost. That is maker positioning, not a guarantee for your task. Compare their results and effort settings against your acceptance checks. OpenAI model catalog.

Which AI model is best for reasoning?

There is no workload-independent winner established by this guide. Compare current candidates using the same evidence, checks and completion requirements. Include time, retries and generated tokens in the decision.

Which AI is good in logical reasoning?

The current OpenAI, Claude, Gemini and DeepSeek reasoning models are candidates. For logic-heavy work, provide explicit constraints and verify the conclusion with an independent calculation, test or source where possible.

Is ChatGPT a reasoning model?

ChatGPT is the application. Reasoning is a capability of the model and configuration used inside it. The app's thinking controls and an API's effort fields are different interfaces; use the slider guide linked above for the app workflow.

Get the newsletter for practical guidance on choosing and operating AI tools.