# AI Reasoning Models Explained: Chain-of-Thought, Test-Time Compute, and When to Pay for Thinking (2026)
> Reasoning models spend extra compute thinking before they answer. Here is how chain-of-thought, test-time compute, and RL training work, with a decision framework for when paying for thinking is worth it.
- Source: https://www.taskade.com/blog/reasoning-models
- Published: 2026-06-18
- Author: Taskade Team
In September 2024, OpenAI previewed a model that did something strange: it paused, thought, and only then answered. On AIME 2024, a hard high-school math contest, the previous flagship (GPT-4o) scored about **12%**. The thinking model scored about **74%** pass@1. Nothing about the training data changed that much. What changed was *when* the compute was spent, at answer time, not just at training time.
That shift created a new category: the **reasoning model**. By 2026 it's everywhere, and it raises a practical question every builder now faces, when is it worth paying for a model to think, and when are you just burning money and latency on a task a fast model would have nailed? This is the vendor-neutral guide.
> **TL;DR:** A reasoning model spends extra inference compute, **test-time compute**, generating intermediate "thinking tokens" before it answers, which makes it far stronger on math, code, and planning but slower and pricier. Use it for hard multi-step problems; use a standard model for lookups and chat. The real answer isn't one model. It's matching the model class to the job. [Taskade](https://www.taskade.com/create) offers frontier models, and TSK-1 Auto handles the default.
---
## What Is an AI Reasoning Model?
An AI reasoning model is a large language model trained to spend extra computation thinking before it answers. Where a standard model predicts its response in essentially one pass, a reasoning model first generates a chain of internal reasoning, exploring, checking, and sometimes backtracking, and only then commits to a final answer. The psychologist's shorthand is useful here: standard models are **System 1** (fast, intuitive), reasoning models add **System 2** (slow, deliberate).
```mermaid
flowchart LR
P["Prompt"] --> S1["Standard LLM
single forward pass"]
S1 --> A1["Answer
fast, cheap"]
P --> R1["Reasoning model
generate thinking tokens"]
R1 --> R2["explore · check ·
backtrack · verify"]
R2 --> A2["Answer
slower, costlier, stronger"]
style P fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style S1 fill:#11111b,color:#cdd6f4,stroke:#00d4aa
style A1 fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
style R1 fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
style R2 fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style A2 fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
```
The mechanism is grounded in three ideas the field assembled over four years, chain-of-thought, test-time compute, and reinforcement learning. Understand those three and you understand every reasoning model on the market. (For the layer below this, how a model turns tokens into predictions at all, see [how large language models work](https://www.taskade.com/blog/how-do-llms-work).)
---
## Reasoning Model vs. Standard LLM: What Actually Changed
The difference is *when and how much* the model computes, not what it fundamentally is. A standard LLM and a reasoning model are both transformers trained on text. The reasoning model is additionally trained to produce a long internal reasoning trace and is given the inference budget to do so. That single change cascades into every practical trade-off you care about.
| Dimension | Standard LLM | Reasoning model |
|---|---|---|
| Inference pattern | one forward pass, next-token | generates reasoning tokens, then answers |
| Latency | sub-second to seconds | 5 to 60+ seconds |
| Cost per answer | lower | higher (you pay for thinking tokens) |
| Best tasks | lookup, summarize, chat, classify | math, code, multi-step planning, agents |
| Weakness | struggles on multi-step logic | over-thinks simple tasks; slow; pricey |
The headline that made everyone pay attention: on **AIME 2024**, GPT-4o scored roughly **12%**, while OpenAI's o1 scored about **74%** pass@1 (higher still with consensus voting) and o1-mini about **70%**. The model class, not a bigger training run, closed most of that gap.
---
## The Three Ideas Behind Reasoning
Reasoning models stand on three building blocks, each solving a limitation of the last. They arrived in sequence, and the sequence is the clearest way to understand the category.
| Idea | Year / source | What it added | Key result |
|---|---|---|---|
| Chain-of-thought | 2022, [Wei et al.](https://arxiv.org/abs/2201.11903) | reason in steps before answering | emergent at ~100B+ params; inference-time only |
| Test-time compute scaling | 2024, [Snell et al.](https://arxiv.org/abs/2408.03314) | spend more compute at answer time | a smaller model can beat one up to 14x larger |
| RL for reasoning (GRPO) | 2025, [DeepSeek-R1](https://arxiv.org/abs/2501.12948) | train reasoning via rewards, not prompts | AIME pass@1 15.6% → 71.0% through pure RL |
**Chain-of-thought** ([Wei et al., Google, January 2022](https://arxiv.org/abs/2201.11903)) showed that simply prompting a large model to "think step by step" dramatically improved multi-step accuracy. But only above ~100B parameters, and only as an inference-time trick, not a change to the weights.
**Test-time compute** ([Snell et al., 2024](https://arxiv.org/abs/2408.03314)) reframed CoT as a *scaling axis*: spend more compute when answering, and accuracy rises. Their compute-optimal finding is the one to remember, a smaller model, given the right thinking budget, can outperform a model **up to 14x larger** at matched compute, and the best strategy depends on problem difficulty.
**Reinforcement learning** turned the prompt trick into a trained behavior. [DeepSeek-R1 (January 2025, later published in Nature)](https://arxiv.org/abs/2501.12948) used **Group Relative Policy Optimization (GRPO)**, which drops the separate critic model and estimates the baseline from a group of sampled answers, to reward correct, verifiable answers. Through pure RL, DeepSeek-R1-Zero's AIME 2024 pass@1 climbed from **15.6% to 71.0%** (and 86.7% with majority voting). Crucially, DeepSeek released R1 as **open weights** with distilled Qwen and Llama variants, putting reasoning in reach of anyone.
---
## How a Reasoning Model Thinks, Step by Step
A reasoning model runs an internal loop before it speaks: it drafts reasoning, checks it against the goal, revises, and only emits the visible answer once it's satisfied (or hits its budget). Those intermediate steps are the **thinking tokens**, usually hidden from you, always billed to you.
```mermaid
sequenceDiagram
participant U as User
participant M as Reasoning model
participant S as Hidden scratchpad
participant V as Self-check
U->>M: Hard question
M->>S: Draft reasoning (thinking tokens)
S->>V: Propose a step
V-->>S: Verify / backtrack if wrong
Note over S,V: Loop until confident or budget hit
M-->>U: Final answer (reasoning hidden)
```
This is why a reasoning answer can take 5 to 60+ seconds: the model is doing real work you don't see. It's also why "over-thinking" is a real cost, point a reasoning model at "what's the capital of France" and you pay for a paragraph of deliberation to produce one word.
---
## Test-Time Compute Scaling: Why Thinking Longer Works
Accuracy rises with thinking compute. But with diminishing returns. The first chunk of reasoning buys the biggest jump; past a point, more thinking adds latency and cost for little gain. Visualizing the curve is the fastest way to build intuition for *how much* thinking to pay for.
```mermaid
xychart-beta
title "Accuracy vs. test-time compute (illustrative)"
x-axis "Thinking compute (log scale)" [none, low, medium, high, max]
y-axis "Accuracy %" 0 --> 100
line [30, 58, 74, 82, 85]
```
The shape is the point: the climb from "none" to "medium" is steep; the climb from "high" to "max" is nearly flat. Snell's compute-optimal result formalizes this. There's a *right* amount of thinking for a given problem difficulty, and spending past it is waste. That single insight is the foundation of the decision framework below.
---
## When to Use a Reasoning Model vs. a Standard Model
Use a reasoning model when a wrong intermediate step ruins the answer; use a standard model when the task is a lookup, a rewrite, or high-volume. The dividing line is whether the problem is *multi-step and verifiable*. Math, code, and agent planning qualify. Summarizing an email does not.
```mermaid
flowchart TD
Q1{"Is the task multi-step
math, code, or planning?"} -->|No| STD["Standard model
fast + cheap"]
Q1 -->|Yes| Q2{"Does a wrong step
compound or break things?"}
Q2 -->|No| STD
Q2 -->|Yes| Q3{"High-volume or
latency-sensitive?"}
Q3 -->|Yes| ROUTE["Route: reasoning only
for the hard subset"]
Q3 -->|No| REASON["Reasoning model
worth the thinking cost"]
style Q1 fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style Q2 fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style Q3 fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style STD fill:#11111b,color:#cdd6f4,stroke:#00d4aa
style REASON fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
style ROUTE fill:#1a140a,color:#ffb74d,stroke:#e65100,stroke-width:1.5px
```
| When to pay for thinking | Use a reasoning model? | Why |
|---|---|---|
| Multi-step math / proofs | Yes | each step must be correct |
| Code generation + debugging | Yes | logic errors compound |
| Agent planning / tool sequencing | Yes | a bad plan wastes every tool call |
| Lookup / Q&A from context | No | a fast model is enough |
| Summarize / rewrite | No | no multi-step logic |
| High-volume classification | No | cost and latency dominate |
---
## The 2026 Reasoning-Model Lineup
By 2026, every major lab ships a reasoning model, and they expose "thinking" in different ways. Naming them is education, not endorsement, the point is that the *category* is now standard, and each option trades off openness, cost, and control differently.
| Model family | How thinking is exposed | Open or closed | Standout strength |
|---|---|---|---|
| OpenAI o-series / GPT-5 thinking | hidden reasoning tokens; real-time router | closed | auto-routing fast vs. deep |
| DeepSeek-R1 | full reasoning trace; RL-trained | open weights | accessible, distillable |
| Claude extended / adaptive thinking | `budget_tokens` / effort parameter | closed | tunable thinking budget |
| Gemini 2.5 thinking | `thinkingBudget`; Deep Think mode | closed | thinking with 1M+ context |
A few verified specifics worth knowing: [OpenAI's GPT-5](https://openai.com/index/introducing-gpt-5/) (August 2025) is a unified system with a fast model, a deeper "GPT-5 thinking" model, and a router that picks between them; OpenAI reports it matches its prior reasoning model with **50–80% fewer output tokens**. Anthropic's Claude exposes extended thinking via a `budget_tokens` parameter (minimum 1,024) and interleaved thinking across tool calls. Google's Gemini 2.5 models carry a configurable `thinkingBudget`. The throughline: **thinking is becoming a dial, not a fixed mode.** For the September 2026 generation, [what GPT is and where GPT-6 fits](https://www.taskade.com/blog/what-is-gpt) covers how the Astra, Sol and Luna tiers split that dial by price.
---
## How to Control Thinking Depth: and Why Routing Is the Real Answer
The single biggest cost mistake in 2026 is running every request through a reasoning model. The fix has two parts: cap thinking depth where the platform allows it (budgets, effort levels), and, more importantly, **route by task difficulty** so only the hard requests pay for deliberation.
```mermaid
flowchart LR
T["Incoming task"] --> R{"Router assesses
difficulty + intent"}
R -->|simple / high-volume| F["Fast standard model"]
R -->|hard / multi-step| D["Deep reasoning model"]
F --> O["Response"]
D --> O
style T fill:#0d1b2a,color:#7dd3fc,stroke:#38bdf8,stroke-width:1.5px
style R fill:#2a1225,color:#ff8fa3,stroke:#ff2d60,stroke-width:2px
style F fill:#11111b,color:#cdd6f4,stroke:#00d4aa
style D fill:#1a0d24,color:#ce93d8,stroke:#6a1b9a,stroke-width:1.5px
style O fill:#0d1a0e,color:#86efac,stroke:#22c55e,stroke-width:1.5px
```
OpenAI built this routing logic into GPT-5. The deeper conclusion from Snell's compute-optimal finding is that routing is *correct in principle*: since the best amount of thinking depends on difficulty, a system that matches model class to task beats committing to one model for everything.
```
ROUTING, AS A RULE OF THUMB
┌───────────────────────────┬──────────────────────────┐
│ "What's our refund policy" │ → fast model (~$, ~1s) │
│ "Summarize this thread" │ → fast model (~$, ~2s) │
│ "Debug this failing test" │ → reasoning ($$, ~20s)│
│ "Plan a 6-step migration" │ → reasoning ($$, ~30s)│
└───────────────────────────┴──────────────────────────┘
Same workspace, many models. TSK-1 Auto handles the default.
```
This is exactly how reasoning fits into [the AI agent stack](https://www.taskade.com/blog/ai-agent-stack): the reasoning layer is the model and the routing logic around it, and [agentic workflows](https://www.taskade.com/blog/agentic-workflows-explained) lean on reasoning for the planning step where a bad decision wastes every downstream [tool call](https://www.taskade.com/blog/ai-agent-tools).
---
## Reasoning Inside Taskade: Thinking Without the Configuration
Taskade gives you the conclusion without the wiring. Agents and automations get access to **frontier models from top AI labs**, and **TSK-1 Auto** handles the default, so you can reach for extended reasoning when a job needs deep problem-solving and a fast model when it doesn't.
That means a [custom agent](https://www.taskade.com/agents) handling your support inbox can run on a fast model while a second agent takes the gnarly edge case on a reasoning model, in the same workspace, and TSK-1 Auto handles the default on anything you do not pin. It's the same philosophy as [Taskade EVE](https://www.taskade.com/blog/eve-meta-agent), the meta-agent that builds [Taskade Genesis](https://www.taskade.com/create) apps: describe the goal, and the workspace assembles the agents, tools, and memory around it. Reasoning becomes a property of the workspace, not a configuration chore, and it pairs with [persistent agent memory](https://www.taskade.com/blog/ai-agent-memory) and [100+ integrations](https://www.taskade.com/automate) so the thinking happens over your real data and acts on real systems.
---
## Frequently Asked Questions About AI Reasoning Models
### What is an AI reasoning model in simple terms?
It's an LLM trained to think before it answers, generating intermediate reasoning steps (often hidden) to work through hard problems, then returning a final answer. That extra inference-time work, called test-time compute, is why reasoning models score far higher on math and code but cost more and respond slower than standard models.
### How is a reasoning model different from a standard LLM?
A standard LLM answers in roughly one forward pass; a reasoning model first generates reasoning tokens, checks its work, and then answers. The result is stronger multi-step performance but 5 to 60+ second latency and higher cost, since you pay for the thinking tokens. For lookups and chat, a standard model is the better pick.
### What is chain-of-thought reasoning?
Chain-of-thought is getting a model to reason step by step before answering. Introduced by Wei et al. at Google in January 2022 (arXiv:2201.11903), it's an emergent ability that only helps at roughly 100B+ parameters and is purely an inference-time technique. Modern reasoning models train this behavior in via reinforcement learning rather than relying on a prompt.
### What does test-time compute mean?
It's the computation a model spends at inference, after training, to think before answering, a third scaling axis beyond more parameters and more data. Snell et al. (2024) showed compute-optimal test-time scaling can let a smaller model beat one up to 14x larger at matched compute, with the best strategy depending on problem difficulty.
### What are thinking tokens and do I pay for them?
Thinking tokens are the internal reasoning generated before the visible answer. They're usually hidden but billed as output tokens, which is why reasoning costs more. Most models let you cap the budget, Claude via `budget_tokens` (minimum 1,024), Gemini via `thinkingBudget`. So you control how much the model spends thinking.
### When should I use a reasoning model instead of a standard model?
Use reasoning for multi-step math, code, complex planning, and agent workflows where a wrong step compounds. Use a standard model for lookups, summaries, classification, chat, and high-volume work where speed and cost win. For most teams the right move is routing each task to the right class automatically.
### Is o1 or DeepSeek-R1 better for reasoning?
Both are strong with different trade-offs. o1-preview (September 2024) pioneered hidden reasoning tokens; the o1 series scored ~74% pass@1 on AIME 2024 versus ~12% for GPT-4o. DeepSeek-R1 (January 2025, published in Nature) reached ~79.8% pass@1 on AIME 2024 and shipped as open weights with distilled smaller variants. Choose based on whether you need open weights, cost, and latency.
### Are reasoning models slower and more expensive?
Yes. They generate reasoning tokens before answering, so they respond in 5 to 60+ seconds and bill those tokens, making each answer pricier. The payoff is much higher accuracy on hard tasks. The waste is over-thinking simple tasks, which is why controlling depth and routing by difficulty matter. For measured numbers, [what one AI task really costs](https://www.taskade.com/blog/ai-cost-per-task) shows Claude Opus 5.5 at $1.34 per Artificial Analysis task on medium effort and $5.98 on max.
### Can a smaller reasoning model beat a bigger standard model?
Yes, on the right tasks. Snell et al. (2024) found compute-optimal test-time scaling can let a smaller model outperform one up to 14x larger at matched compute, and DeepSeek-R1's distilled variants reason well at small sizes. How a model uses inference compute can matter as much as raw size.
### Do I have to choose one reasoning model, or can I route between them?
You can route. GPT-5 (August 2025) ships a real-time router between a fast and a thinking model. Platforms can offer the same range: Taskade gives you frontier models, and TSK-1 Auto handles the default, so choosing a model is optional.
### How does reinforcement learning train a reasoning model?
RL rewards a model for reaching correct, verifiable answers, which pushes it to develop useful reasoning. DeepSeek-R1 used GRPO, which drops the critic model and estimates the baseline from a group of sampled answers to cut cost. Through pure RL, DeepSeek-R1-Zero's AIME 2024 pass@1 rose from 15.6% to 71.0%. The places that reward happens are called [RL environments](https://www.taskade.com/blog/reinforcement-learning-environments), and they are where a large share of AI progress now comes from.
### Does Taskade support reasoning models?
Yes. Taskade gives agents frontier models from top AI labs, including reasoning models, and TSK-1 Auto handles the default. You can reach for extended reasoning on hard problems and a fast model otherwise, with no model configuration. Taskade starts free, with paid plans from $10/month billed annually.
---
The reasoning-model era didn't make models bigger. It made them *think*. The skill it asks of you isn't picking the smartest model; it's knowing which problems deserve deliberation and which just need a fast, correct answer. Master that and you stop overpaying for thinking you don't need, and start spending it exactly where it changes the outcome.
That's the reasoning layer of the stack: Memory feeds it context, Intelligence does the thinking, Execution acts on the result, on a loop. **▲ ■ ●**
*Want reasoning built into your work without the configuration? [Start free with Taskade Genesis](https://www.taskade.com/create), let TSK-1 Auto handle the default for your [AI agents](https://www.taskade.com/agents), and wire it into [automations](https://www.taskade.com/automate).*