Why some AI models think before they answer

Last week, OpenAI announced that an internal version of its next model, called Astra, had solved ten open problems in mathematics and theoretical computer science. Each of the problems had been open for at least a decade. The results were achieved by an internal version of Astra, and the total number of tokens needed to find the solutions would cost roughly $2,000 at current API rates. That last detail is worth sitting with. Two thousand dollars for a decade of unsolved maths.

The story got plenty of coverage, including on this site. But something important was missing from most of it: an explanation of how a model even attempts something like that. The answer has nothing to do with having a bigger list of facts. It has everything to do with a shift in how AI uses its thinking time. That shift has a name: reasoning models.

What a standard AI model actually does

To understand what a reasoning model is, you first need a clear picture of what a standard large language model does when you ask it something.

The short version is that it pattern-matches at very high speed. It has seen enormous amounts of text, learned statistical relationships between words and ideas, and can produce fluent, plausible-sounding responses almost instantly. The key word there is instantly. A standard model commits to a direction and keeps going. A standard AI commits to the first plausible path.

The psychologist Daniel Kahneman wrote about two modes of human thought: System 1, which is fast, automatic, and intuitive, and System 2, which is slow, deliberate, and analytical. Standard language models operate primarily in System 1 mode: fast pattern matching with impressive surface-level fluency. That works well for most things. Ask a standard model to summarise a document, translate a sentence, or help you write a birthday message, and its speed is a virtue. The task doesn't require deep reasoning. It requires good pattern recognition, and that's exactly what these models are good at.

The problem arises when you give it a hard maths problem, a multi-step logical puzzle, or a genuinely novel question with no obvious precedent in the training data. The model's instinct to produce a fluent, confident answer quickly becomes a liability. It guesses, commits, and often gets it wrong in ways that look surprisingly convincing.

What makes a reasoning model different

A reasoning model spends extra compute at inference time, generating intermediate "thinking tokens" before it answers, which makes it far stronger on maths, code, and planning, but slower and more expensive.

In practice, this means the model generates a long internal chain of thought before it shows you anything. The model generates a long internal thinking trace, a sequence of reasoning steps, exploratory calculations, self-corrections, and backtracking, before producing the final response you see. The thinking trace is usually hidden, though some interfaces show it. The model might explore three approaches to a maths problem, notice that the first two lead to contradictions, and arrive at the correct answer via the third.

The shift OpenAI demonstrated when it previewed its first reasoning model back in late 2024 was striking. On the AIME 2024 hard maths contest, the previous flagship model scored about 12%. The thinking model scored about 74%. Nothing about the training data changed that much. What changed was when the compute was spent, at answer time rather than only at training time.

That is the key insight. These models are not necessarily smarter in the sense of having learned more. They are smarter in the sense of being given time to work things out, rather than being forced to answer immediately.

What the thinking actually looks like

If you have ever used Claude's "extended thinking" mode or seen OpenAI's reasoning trace, you'll have noticed that the internal monologue can look almost embarrassingly human. The model second-guesses itself, tries a new approach, catches an error, backs up, and tries again.

This is not a performance. It is genuinely how these models produce better answers. The intermediate steps are real computation. The model is using each step as scaffolding for the next one, keeping track of constraints and ruling out dead ends. It is the difference between doing long division in your head (fast, error-prone) and writing each step down on paper (slower, but far more reliable for a complex calculation).

Reasoning models are a class of AI systems designed to perform logical, multi-step thinking. Instead of responding immediately, these models analyse the problem, create intermediate steps, and then produce a final answer.

One thing worth noting: the model's chain of thought is not a post-hoc explanation. Standard AI models often produce explanations of their answers that are, frankly, made up after the fact, a rationalisation rather than a real account of how the answer was reached. With reasoning models, the thinking trace is doing actual work. It is the mechanism, not the justification.

The Astra result in this light

Go back to the Astra announcement with this in mind and it starts to make more sense. OpenAI published a 249-page manuscript alongside machine-checkable Lean 4 certificates for every result on GitHub. Those certificates are important: they mean anyone can run the proof through a formal verification system and confirm it is logically valid, step by step, with no gaps.

The headline result was a proof that non-sofic groups exist. Stripped of the terminology, a group is the mathematical description of a set of symmetries, and a sofic group is one whose structure can be approximated by shuffling a finite deck of cards. Every group anyone had examined turned out to be sofic, and no one could prove that all of them are. Astra built the exception. No mathematician had managed to prove or disprove whether non-sofic groups exist in the 27 years since the concept was introduced.

The reason a reasoning model can attempt this kind of work, where a standard model cannot, is precisely the ability to explore, backtrack, and verify intermediate steps. Maths proofs have no room for plausible-sounding approximations. Every step must follow from the last. That is exactly the kind of task where extended thinking time pays off.

The solutions span diverse fields including group theory and high-dimensional geometry, and are notable for their accompanying machine-checkable proofs. Published in Lean on GitHub, these certificates allow instant, trustless verification.

The practical trade-offs

Reasoning models are not a straight upgrade. They come with real costs.

Where a standard model might respond in two to four seconds, a reasoning model might take 20 to 60 seconds for the same prompt. On hard problems that is a fair trade. On simple ones, it is overkill.

They are also considerably more expensive to run, because generating all those intermediate thinking tokens uses more compute. And they can sometimes over-think simple questions, producing elaborate reasoning chains for tasks that just need a quick answer.

The frontier of AI capability in 2026 has split into two tracks: fast, efficient standard models for everyday work, and slow, powerful reasoning models for the hardest problems.

The practical question for anyone using AI is therefore not "which model is best" but "what does this task actually need?" Most routine workplace AI tasks, like drafting communications, summarising meetings, and generating first-draft content, are genuinely System 1 tasks. They benefit from speed, and a standard model is the right tool. But a growing category of high-value, high-stakes tasks requires System 2 rigour: financial modelling, legal document analysis, clinical decision support, complex software architecture, and strategic scenario planning.

If this one was useful, there's plenty more on the site. Pieces on how AI works, plus coverage of AI news, the downsides included. All free to read, no account needed.

Why this distinction is about to matter more

Until recently, most people interacted with AI through interfaces that made this choice for them. ChatGPT, Gemini, and Claude would just answer, and you had no say in how much thinking they did. That is changing. Most of the major AI products now let you toggle between a fast mode and a thinking mode, and some switch automatically depending on what you ask.

Understanding what that toggle actually does changes how you use these tools. If you are asking for a recipe, you do not need 60 seconds of internal deliberation. If you are asking an AI to check whether a legal clause is consistent with three other clauses in a contract, you probably do.

The broader implication is that the Astra maths result is not really a story about one impressive model solving hard problems. It is a story about a fundamental change in how AI systems are designed to think. The gap between a model that pattern-matches and a model that genuinely works through a problem is the gap between a very well-read person giving you their instinctive reaction and a very well-read person sitting down with a pen and paper to think it through carefully.

Both have their uses. Knowing which one you are talking to is increasingly worth understanding.