Reasoning Models Explained: o3, DeepSeek-R1 and the Thinking Revolution

For years, making AI better meant one thing: train a bigger model. Simple recipe, eye-watering bills. Then OpenAI’s o1 introduced a second lever, and honestly, the field hasn’t been the same since.

Here’s the idea in one sentence: instead of answering instantly, reasoning models like o3, DeepSeek-R1, Claude’s extended thinking and Gemini’s thinking mode generate long internal chains of thought before they reply. They spend extra compute at the moment you ask, not just during training. And the results on hard problems? The biggest capability jump since GPT-4. Let’s look at what’s actually going on.

Thinking fast versus thinking slow

A standard LLM answers in one pass per token: fluent, instant, and prone to a classic failure. It commits to a wrong first step, then rationalizes from there with total confidence. Ask it a multi-step math problem and it guesses the shape of the answer.

A reasoning model does something different. It produces hundreds, sometimes thousands, of hidden tokens of scratch work first. It tries an approach, checks it, backtracks, and only then writes the final answer. You pay in time and tokens. You get answers that were actually worked out.

The analogy everyone reaches for is Kahneman’s System 1 and System 2, and honestly, it fits. Standard models think fast; reasoning models think slow. The engineering trick underneath is training, via reinforcement learning on verifiable problems like math and code, the habit of productive deliberation.

DeepSeek-R1: the moment the secret got out

OpenAI kept o1’s recipe quiet. Then, in January 2025, DeepSeek published R1: open weights, a transparent technical report, and performance matching o1 on key reasoning benchmarks, trained at a fraction of the expected cost.

The market reaction was surreal: hundreds of billions wiped off chip stocks in a single day. Not because R1 was better, but because it proved the technique was reproducible by any well-funded lab, anywhere. Within months, every major lab shipped reasoning modes, and open variants flourished.

And here’s a detail we love: R1’s visible chain of thought, which you can watch unfold live in its app, did more to popularize the concept than any research paper ever could.

Where reasoning models dominate

• Mathematics and logic. Competition math went from embarrassing to near-saturation on many benchmarks. Genuine multi-step derivation is the signature win.
• Complex code. Debugging subtle issues, designing algorithms, reasoning about large systems. The thinking traces catch mistakes that fast models plow straight through.
• Planning and analysis. Multi-constraint problems, comparing options with trade-offs, structured research. Our testing shows the clearest everyday gains right here.
• Agentic tasks. Reasoning models drive the best agents, because deciding what to do next over many steps is exactly what deliberation is.

Where they are overkill (or worse)

Reasoning isn’t free, and it isn’t always better. Drafting an email? Summarizing a document? Brainstorming names? A standard model answers in two seconds, the reasoning model answers in twenty, and you won’t perceive any quality gain. Worse, on some creative tasks the deliberation smooths away the spark. There’s even a documented failure mode of overthinking simple questions into wrong answers.

The smart products now route automatically: fast model for easy asks, thinking mode for hard ones. If yours doesn’t, switch manually. It’s the single highest-leverage habit for using these tools well.

The economics: intelligence on tap, priced per thought

Here’s what catches teams off guard. A hard question can consume a hundred times the tokens of a simple one, and API pricing reflects that. Reasoning tokens are billed, and the bills surprise anyone who migrates workloads naively.

The flip side is remarkable, though: problems that used to require expensive human expert time now cost a few dollars of compute. The skill of the era is routing, knowing which questions deserve the expensive thinking and which don’t.

There’s also a frontier effect worth knowing. Test-time compute keeps scaling: give these systems a bigger thinking budget and answers keep improving on the hardest problems. That’s why labs talk about models that think for hours, and why agents that work autonomously all day suddenly look plausible.

How to get the most from a reasoning model

1. State the goal and constraints, then get out of the way. Reasoning models need less hand-holding than standard ones. Detailed step-by-step instructions can actually hurt.
2. Give it the materials. Paste the data, the error, the document. Reasoning amplifies good inputs; it can’t fix missing context.
3. Ask it to verify. “Check your answer” engages exactly the machinery these models are trained on.
4. Use thinking traces as review. Where they’re visible, skim the chain. It reveals assumptions you may want to correct.

How we test reasoning models. We maintain a fixed set of hard problems across math, code, planning and analysis, and we run every major reasoning model against it on release, comparing both final answers and failure modes. Sponsor-free, protocol public on our methodology page.

The limits of thinking longer

Reasoning models feel magical on their home turf, so let’s be precise about where the magic stops. First, they cannot reason about facts they don’t possess. Ask a question requiring private or very recent information without supplying it, and you’ll get a beautifully argued wrong answer. Deliberation amplifies knowledge; it doesn’t replace it.

Second, the chains of thought aren’t guaranteed faithful. Research shows the visible reasoning doesn’t always reflect the actual computation, so treat traces as a helpful narrative, not an audit log. Third, cost scales with difficulty in ways pricing pages understate: the hardest queries can cost a hundred times the average.

None of this diminishes the advance. It defines the skill of using it: supply the facts, verify the conclusions, reserve deep thinking for problems that deserve it.

The bottom line

Where does this go next? The trajectory is clear: thinking budgets grow, cost per thought falls, and the line between “assistant” and “colleague who works on the problem overnight” keeps blurring. The users getting the most from reasoning models aren’t the ones who use them most. They’re the ones who route to them most precisely.

For practical guidance on which products implement reasoning best today, see our assistant comparison and the rest of our LLM coverage.