8 Best Reasoning Models in 2026 and What They Actually Cost

Thinking is now the default at the top of the model market. Claude Opus 5.5, GPT-6.1 Sol, Gemini 4 Argon, Grok 4.7, and Kimi K3 all reason on every request, and none of them offers a setting that turns reasoning off.

That thinking has a price. Reasoning tokens bill like output, often without showing up in the response, and default effort settings range from medium on some models to max on others. Because of that, two models with similar per-token rates can produce very different bills for the same request.

The right pick is the cheapest model, at the lowest effort level, that still clears your quality bar on your own tasks. Getting there means looking past headline scores to how each model spends and bills its thinking.

These are the 8 best AI reasoning models in 2026 and what they actually cost to run.

TL;DR: Best AI reasoning models at a glance

Each model fits a different kind of work and a different reasoning budget:

• Claude Opus 5.5 - Long-horizon agentic work and coding, with thinking always on and effort set to medium by default.
• GPT-6.1 Sol - Complex coding and research at $2/$10 per 1M tokens, with five effort levels and no off switch.
• Gemini 4 Argon - Agentic coding and very long outputs, at a rate that doubles on December 1, 2026.
• Grok 4.7 - Agents that need live web or X search, running at high effort unless you set it lower.
• DeepSeek V4.1 Flash - Open-weight reasoning under the MIT license at a fraction of flagship prices, with visible reasoning and an off switch.
• Kimi K3 - Open-weight science and knowledge reasoning (Moonshot reports 93.5 on GPQA Diamond), running at max effort by default.
• Qwen3.8-Max - Workloads that need a hard cap on thinking tokens.
• GPT-6 Luna - High-volume steps at $0.10/$0.50 per 1M tokens, with reasoning you can turn off.

For agents where most calls are simple, a model with an off switch (Luna, DeepSeek V4.1 Flash, or Qwen3.8-Max) can handle both the simple steps and the hard ones from a single model ID. Respan's AI gateway routes every call through one API to 1,000+ models and prices each request, so you can see what each step costs and route it to the model it needs.

What are AI reasoning models?

AI reasoning models are large language models that work through a problem in intermediate steps before writing their final answer. Instead of producing a response in one pass, they generate a stretch of reasoning first, which lets them break a task down, test an approach, and correct course before committing to an output.

The line between a reasoning model and a flagship model has mostly closed, since the top models from Anthropic, OpenAI, Google, xAI, and Moonshot all think by default, so among the types of AI models developers choose between, reasoning is more often a setting than a separate model. Overall capability is the lens for ranking the best frontier AI models. For reasoning models, the deciding factors are how much each one thinks and what that thinking costs you.

How do AI reasoning models work?

Reasoning models spend extra compute at inference time, and the provider gives you a dial for how much.

Thinking before answering

A reasoning model generates a chain of intermediate tokens before it writes the answer. In that chain it breaks the problem into steps, tries an approach, checks it, and revises. Labs train this behavior with reinforcement learning on tasks with verifiable outcomes, such as math problems with known answers and code that has to pass tests, so the model learns that spending more tokens on a hard problem raises the odds of getting it right.

More thinking usually means better answers on multi-step problems. It also means higher latency and a bigger bill, which is why all eight models give you some control over how much they think.

Effort levels and thinking budgets

Most providers expose an effort parameter with named levels, while Qwen3.8-Max uses an on/off switch and a token budget instead. The level names look similar across APIs, but the defaults don't line up. If you never set the parameter, Kimi K3 runs at max effort and Grok 4.7 at high, while Claude Opus 5.5 and GPT-6.1 Sol run at medium.

Set the parameter explicitly in production so a provider's default change doesn't move your costs. Anthropic lowered the default from high on Opus 5 to medium on Opus 5.5, and a request that left effort unset changed behavior with the model upgrade.

How reasoning tokens are billed

Anthropic, OpenAI, Google, and Alibaba state that thinking tokens bill at the output rate. DeepSeek and Moonshot count reasoning toward token usage as well, and xAI bills it as part of total consumption without naming the rate.

What you see varies more than what you pay. OpenAI returns no reasoning text, Gemini returns thought summaries only when you request them, and Claude Opus 5.5 omits thinking text by default. DeepSeek, Kimi, and Qwen return the full reasoning in a reasoning_content field. Anthropic notes that thinking bills in full even when the text isn't returned, and its summarized display still bills the complete thinking, so the token count on your invoice won't match the text in your logs.

What are reasoning models typically used for?

Reasoning models earn their cost on tasks where the answer depends on intermediate steps the model has to get right:

• Multi-step agents and tool calling - An agent that plans, calls a tool, reads the result, and adjusts gets better results when it can reason between calls. Claude Opus 5.5 interleaves thinking between tool calls automatically, and DeepSeek V4.1 Flash can run several rounds of reasoning and tool calls before it answers.
• Coding and debugging - Tracing a bug across files, planning a refactor, or fixing a failing test suite. Most labs now lead their launch numbers with agentic coding benchmarks such as DeepSWE and Terminal-Bench.
• Math and science problems - Multi-step derivations and graduate-level science questions, the territory benchmarks like GPQA Diamond and Humanity's Last Exam measure.
• Long-document analysis - Contracts, codebases, and research corpora that fill a 1M-token context window, where the model has to connect facts that sit far apart.

In each of these, a wrong intermediate step produces a wrong final answer, which is the failure that extra thinking is built to catch.

When not to use a reasoning model

A lot of the calls inside a production app don't need the model to think, and paying for reasoning on them adds cost and latency without improving the output:

• Extraction and classification - Pulling fields from a document or labeling a support ticket has one right answer that doesn't require planning.
• Latency-sensitive responses - Voice agents, autocomplete, and live chat feel slow when thinking delays the first visible token.
• Simple steps inside an agent - Formatting a tool result, summarizing a short page, or picking the next tool from a short list.
• High-volume batch jobs with fixed formats - Rewriting product descriptions or tagging records at scale, where small per-call savings add up across millions of requests.

On models with an off switch, the fix is a parameter change: none on GPT-6 Luna, disabled thinking on DeepSeek V4.1 Flash, or enable_thinking: false on Qwen3.8-Max. For models that always think, an LLM router can send those calls to a cheaper non-reasoning model instead.

8 best reasoning models compared

Benchmark scores in each entry are the lab's own reported numbers. The labs don't publish the same benchmarks, so a score is only comparable to another lab's score on the same test.

Prices are per 1M input and output tokens at standard rates.

1. Claude Opus 5.5

Claude Opus 5.5 can't run without thinking. Anthropic's adaptive thinking is always on, and output_config.effort controls how deep it goes rather than whether it happens. Anthropic reports 67.7% on Humanity's Last Exam with tools, 66.4% on Terminal-Bench 4.0 at xhigh effort, and 81.8% on OSWorld 2.1. Interleaved thinking between tool calls needs no extra setup, which suits agents that plan across long chains of tool calls.

Forced tool use isn't supported (tool_choice accepts only auto or none), and changing temperature from its default returns an error. Anthropic also points to Claude Fable 5.1, at $10/$50 per 1M tokens, for its most demanding reasoning work when Opus 5.5 at higher effort still falls short. Opus 5.5 still scores higher on every benchmark in Anthropic's own launch table, a split worth reading through in the Fable 5.1 vs Opus 5.5 comparison before you pay the higher rate.

• Best for: Long-horizon agentic work and coding
• Reasoning controls: output_config.effort (low to max), medium by default, can't be turned off
• Pricing: $4 input / $20 output per 1M tokens, with thinking billed as output
• Context window: 1M tokens, 128K max output

2. GPT-6.1 Sol

GPT-6.1 Sol, the newer version of GPT-6 Sol released in late September and the second of OpenAI's four current GPT models, keeps reasoning on for every request. Its reasoning.effort setting runs from low to max with medium as the default, and none isn't accepted. For harder problems, a pro reasoning mode spends more tokens at the same standard rates.

Reasoning stays hidden: the API returns no reasoning text, and stateless requests get encrypted reasoning items that you pass back on the next turn. Tool calling requires the Responses API, where async tool calls let the model keep reasoning while your code runs a tool; Chat Completions accepts no tools for this model. OpenAI also doesn't publish GPQA Diamond, Humanity's Last Exam, or SWE-bench scores for Sol, so you can't line it up against other labs on those tests using OpenAI's own figures. The other cost to plan around is long prompts, since anything over 272K input tokens bills the whole request at 2x input and 1.5x output.

• Best for: Complex coding and research
• Reasoning controls: reasoning.effort (low to max), medium by default, can't be turned off
• Pricing: $2 input / $10 output per 1M tokens, with reasoning billed as output and a surcharge above 272K input tokens
• Context window: 1.05M tokens, 128K max output

3. Gemini 4 Argon

Gemini 4 Argon went generally available on October 13 with a price change already scheduled. Its $2/$10 per 1M token rate doubles to $4/$20 on December 1, 2026, so it makes sense to budget against the higher number. Thinking runs at one of three thinking_level settings (low, medium, or high), with medium as the default and no off level. Google recommends testing all three and keeping the lowest one that meets your quality bar. At its highest thinking setting, Google reports 77.9% on DeepSWE v1.1 and 57.4% on Terminal-Bench 4.0.

Thinking and the answer share one max_output_tokens cap, and Argon can spend more of it on thinking than earlier Gemini models, so Google recommends setting it to at least 32,768. Output tops out at 65,536 tokens on synchronous calls. Long decode raises that to 1M if you run the request in background mode, where you pay for every hop, including hops that contain only thinking. For where Argon sits next to the 3.x Flash models, the Gemini model comparison breaks down the tradeoffs.

• Best for: Agentic coding and long outputs
• Reasoning controls: thinking_level (low, medium, high), medium by default, no off setting
• Pricing: $2 input / $10 output per 1M tokens through November 30, 2026, then $4 / $20, with thinking billed as output at a flat rate for any prompt length
• Context window: 1,048,576 tokens shared by input and output, 65,536 output by default

4. Grok 4.7

Grok 4.7 defaults to high reasoning effort, one step below its xhigh ceiling, so a request that never sets the parameter already runs near the top of its range. Reasoning can't be disabled. xAI reports 71.0% on DeepSWE v1.1 (run by Datacurve) and 46.3% on CursorBench 4.0 at xhigh, and the API includes server-side tools for web search, X search, and code execution inside an agentic loop.

The context window is 500K tokens, half the 1M windows on most of the other models, and the per-token rate doubles once a prompt passes 200K tokens. xAI bills reasoning tokens as part of usage and reports them as reasoning_tokens, though its docs don't say which rate they bill at. Raw reasoning comes back encrypted, with summaries available. If you skip setting prompt_cache_key, xAI warns that requests can land on a cache-cold server and pay full input price, and server-side tool calls bill on top of tokens.

• Best for: Agents that need live web or X search
• Reasoning controls: reasoning_effort (low to xhigh), high by default, can't be turned off
• Pricing: $2 input / $6 output per 1M tokens below 200K tokens, $4 / $12 above, with tool calls billed separately
• Context window: 500K tokens

5. DeepSeek V4.1 Flash

DeepSeek V4.1 Flash is open-weight under the MIT license, and it shows its work: reasoning comes back in a reasoning_content field instead of being hidden or encrypted. The deepseek-flash API model currently serves the October 17 snapshot. DeepSeek reports 90.9 on GPQA Diamond and 63.9 on Humanity's Last Exam with tools for V4.1 Flash, and 77.0 on DeepSWE v1.1 for the October snapshot.

Thinking is on by default at high effort and turns off with thinking: {"type": "disabled"}, so one model ID can serve both reasoning and non-reasoning calls. When a request includes tools, you have to pass reasoning_content back on every later turn, or the API returns a 400 error. DeepSeek's older V4-Pro still scores higher on GPQA Diamond (92.4) at more than three times the price, a tradeoff the DeepSeek model comparison covers in detail. Off-peak pricing cuts the rate in half outside weekday peak windows (01:00 to 04:00 and 06:00 to 10:00 UTC), which makes batch jobs noticeably cheaper.

• Best for: Low-cost reasoning with open weights
• Reasoning controls: reasoning_effort (low, high, max), high by default, thinking can be turned off
• Pricing: $0.30 input / $1.20 output per 1M tokens at peak, $0.15 / $0.60 off-peak
• Context window: 1M tokens, up to 384K output

6. Kimi K3

Kimi K3's reasoning_effort defaults to max, so an unset request runs Moonshot's open-weight flagship at its most expensive setting. Moonshot reports 93.5 on GPQA Diamond and 56.0 on Humanity's Last Exam with tools at max effort. Thinking is always on, there's no separate thinking model ID, and the reasoning comes back in reasoning_content.

The weights are open under a custom Kimi K3 License, but at 2.8T total parameters (104B active), Moonshot recommends supernode setups of 64 or more accelerators for self-hosting, so the API is the realistic path unless you already run that class of hardware. Sampling parameters are fixed (temperature at 1.0, for example), and sending other values returns an error. Changing effort partway through a conversation also invalidates prefix-cache hits, and multi-turn tool loops need the full assistant message passed back, reasoning included.

• Best for: Open-weight science and knowledge reasoning
• Reasoning controls: reasoning_effort (low, high, max), max by default, can't be turned off
• Pricing: $3 input ($0.30 on a cache hit) / $15 output per 1M tokens
• Context window: 1M tokens

7. Qwen3.8-Max

Qwen3.8-Max gives you two separate dials: enable_thinking switches reasoning on or off per request, and thinking_budget caps how many tokens it can spend thinking. Qwen reports 92.6 on GPQA Diamond, 56.2 on Humanity's Last Exam with tools, and 67.7 on SWE-bench Pro. Max itself is API-only, while its open-weight base, Qwen3.8-2.4T-A95B, ships thinking-only and text-only under a custom license, and Qwen3.8-27B is available under Apache 2.0.

Thinking tokens bill as output, and preserve_thinking, which is on by default, feeds earlier reasoning back into the next turn as input. In a long conversation, you pay for old reasoning again on every later turn unless you turn it off. In thinking mode, tool_choice="required" isn't supported, so you can't force a tool call while the model reasons. Prices also vary by region, at $2/$6 per 1M tokens in the Singapore and US regions and $1.65/$4.951 on global deployments and in Beijing.

• Best for: Workloads that need a cap on thinking tokens
• Reasoning controls: enable_thinking (on by default) and thinking_budget (full budget by default)
• Pricing: $2 input / $6 output per 1M tokens in Singapore and US regions, with thinking billed as output
• Context window: 1M tokens, 131K max output, up to 262K reasoning tokens

8. GPT-6 Luna

At $0.10 input and $0.50 output per 1M tokens, GPT-6 Luna costs a twentieth of GPT-6.1 Sol and still reasons when you ask it to. Its reasoning.effort runs from none to max, so setting none turns it into a non-reasoning model for extraction and classification steps. OpenAI reports 66.6% on DeepSWE v1.1 at max effort, and Luna's place as the volume tier below Sol and Astra is laid out in the GPT-6 Sol, Luna, and Astra comparison.

The catch is in how it handles tools. In Chat Completions, function calling only works with effort set to none, so reasoning and tool calls together require the Responses API. OpenAI's own numbers also show a reliability gap on agent work: on an eval that checks whether the model discloses a broken search tool, Luna failed 28.7% of the time, against 2.1% for GPT-6.1 Sol. For steps where a silent tool failure would cause damage, that gap is worth testing before you route traffic to Luna.

• Best for: High-volume steps and low-cost reasoning
• Reasoning controls: reasoning.effort (none to max), medium by default, none turns reasoning off
• Pricing: $0.10 input / $0.50 output per 1M tokens, with reasoning billed as output and the same surcharge above 272K input tokens as Sol
• Context window: 1.05M tokens, 128K max output

What reasoning models actually cost

Standard rates per 1M tokens, from each provider's pricing page as of October 22, 2026:

Reasoning models don't carry a separate price list. The same per-token rates you'd compare across the best LLM APIs apply, and the thinking lands in the output column, which is the more expensive side of each rate. Several billing details change the real number on top of that:

• Reasoning billed twice - Qwen3.8-Max's preserve_thinking sends earlier reasoning back as input on each later turn, so long conversations pay for old thinking again.
• Truncated calls that still bill - On OpenAI models, max_output_tokens covers reasoning and visible output together. If reasoning uses up the limit, the response comes back incomplete and you can be billed with no visible output, which is why OpenAI recommends reserving at least 25,000 tokens. Google gives similar advice for Argon, with a 32,768-token minimum.
• Long-context surcharges - GPT-6.1 Sol and Luna bill the whole request at higher rates above 272K input tokens, and Grok 4.7 doubles above 200K, while Opus 5.5 and Argon keep one rate across their context windows.
• Time-based pricing - Argon's rate doubles on December 1, 2026, and DeepSeek charges half price outside weekday peak hours.

Effort level is usually the fastest lever to pull, and it stacks with other LLM cost optimization strategies like caching and batch discounts.

How to evaluate reasoning models

Published scores narrow the field, but you settle the choice by running candidates against your own workload.

Test on your own traffic, not leaderboards

Leaderboards rank these models on composite scores, but the labs report different LLM benchmarks, and none of those benchmarks used your prompts or your tool schemas. A model that leads on a science benchmark can still struggle with your function definitions or your output format.

Pull a few hundred real requests from production, including ones that failed, and run them through each candidate at two or three effort levels. That gives you a dataset that reflects what your users actually send.

Measure cost per completed task

Per-token price doesn't tell you what a task costs, because a model that thinks longer or needs a retry spends more tokens to get the same result. OpenAI's own figures show how large the gap can get: at max effort, GPT-6.1 Sol completed Terminal-Bench Science tasks for $5.47 each, against $23.80 for GPT-6 Astra.

Divide total spend, retries and failed calls included, by the number of tasks that passed your checks. That number is what to compare across models and effort levels.

Track latency and thinking-token spend

Reasoning tokens arrive before the first visible token, so higher effort shows up as a longer time-to-first-token as well as a bigger bill. Log reasoning tokens separately from visible output where the API reports them; xAI returns them as reasoning_tokens, and DeepSeek under completion_tokens_details.reasoning_tokens.

Hidden reasoning can make a response look cheaper than it was. Anthropic notes that omitting thinking text reduces latency but not cost, so a fast response on Opus 5.5 can still carry a full thinking bill.

Score output quality with evals

Once you know cost and latency at each effort level, the remaining question is whether the cheaper setting still gets the answer right. Define what a good output looks like with an LLM judge, a deterministic code check, or human review, then run each model and effort level against the same dataset and keep the lowest setting that clears the bar.

The broader methods for evaluating LLMs in production apply here too, with effort level treated as one more variable in the experiment. With Respan evals, the same evaluator that scores your dataset before you ship can run on sampled live traffic afterward, so a model update or prompt change that degrades quality shows up before users report it.

How to route every task to the right reasoning model

Choosing a reasoning model per task only pays off if you can see what each call costs and prove that the cheaper choice held up. Respan is the AI router with built-in observability and automated evals, so every request it routes is traced, priced, and scored in the same place. Route, observe, and evaluate every LLM call.

Through Respan's AI gateway, you reach 1,000+ models across every major provider from one API, and moving a step to a different model means changing a single word. Respan Router (beta) takes that further: set the model to span-router, and it picks the model for each task based on the request's context, the capabilities it needs, and cache-aware cost estimates, billed at the serving model's rate with no markup.

• Cost per request and per customer - Every request is logged with its latency and cost, broken down by model, request, and end customer, so you can see which feature or customer drives your spend.
• Hard spend limits - Set soft and hard caps per key, per customer, or org-wide. The soft cap warns you as spend approaches it, and the hard cap stops spend at the ceiling.
• Fallbacks when a provider fails - Define a fallback chain once, and traffic moves to the next model the moment a provider errors or rate-limits.
• Traces for multi-step agents - Each LLM call, tool run, and agent turn becomes a span in one trace with its own input, output, latency, and cost.
• Evals that close the loop - Build datasets from production logs, run experiments that compare models or prompt versions against your evaluators, and click any score to land on the trace behind it.
• Alerts before customers notice - Monitors watch cost, errors, latency, and tokens, and send an alert to Slack, email, or a webhook the moment one breaches.

Instead of reading logs after the fact, use Respan to run observability in production, know when production shifts, and act before it spreads.

FAQ

What is the best AI reasoning model?

No single model leads on every task. Among labs that publish Humanity's Last Exam with tools, Claude Opus 5.5 reports 67.7%, ahead of DeepSeek V4.1 Flash (63.9), Qwen3.8-Max (56.2), and Kimi K3 (56.0), while Google reports 77.9% on DeepSWE v1.1 for Gemini 4 Argon. The best model for a given step is the cheapest one that passes your evals, and Respan Router (beta) picks the model per task so you don't have to hardcode that choice.

Which AI reasoning model is best for coding?

On DeepSWE v1.1, Gemini 4 Argon (77.9%) and DeepSeek V4.1 Flash's October snapshot (77.0) post the highest vendor-reported scores, followed by Grok 4.7 (71.0%). Anthropic doesn't report DeepSWE for Claude Opus 5.5, but reports 66.4% on Terminal-Bench 4.0, where Google reports 57.4% for Argon. Run the candidates on tasks from your own repository before committing; Respan experiments let you compare models side by side against the same dataset.

What is the best open-source reasoning model?

Kimi K3 posts 93.5 on GPQA Diamond, the highest vendor-reported score among the open-weight models from DeepSeek, Moonshot, and Qwen, but self-hosting it takes 64 or more accelerators. DeepSeek V4.1 Flash (MIT license, 90.9 on GPQA Diamond) costs far less to run through the API, and Qwen3.8-27B ships under Apache 2.0 with a much smaller footprint, which matters if you're weighing the best open-source LLMs on hardware cost as much as on scores.

What is the cheapest AI reasoning model?

GPT-6 Luna, at $0.10 input and $0.50 output per 1M tokens, followed by DeepSeek V4.1 Flash at $0.15/$0.60 off-peak ($0.30/$1.20 at peak). The lowest per-token rate doesn't always mean the lowest cost per task, since a model that needs higher effort or retries to pass can cost more overall. Respan breaks down cost by model, request, and customer, so you can see what each task costs in production.

Do AI reasoning models cost more than standard models?

Yes, per request. Thinking tokens bill as output on top of the visible answer, and Anthropic bills them even when the thinking text isn't returned. You can bring the cost down by lowering effort, turning thinking off on models that allow it (GPT-6 Luna, DeepSeek V4.1 Flash, and Qwen3.8-Max), or routing simple steps to a non-reasoning model, and Respan shows cost per request so you can see which calls drive your spend.