Reasoning Is Not the Only Path to Better Models

Since o1 arrived last year, a lot of the frontier-model conversation has shifted toward reasoning: let the model think longer, spend more inference compute, and improve performance on math, science and coding tasks.

That direction is real. But GPT-4.5 is a useful reminder that it is not the only way models can get better.

OpenAI describes GPT-4.5 as its largest GPT model yet and, unlike o1 or o3-mini, it is not built around a chain-of-thought reasoning process before every answer. The company presents it as a scaling step in unsupervised learning: more pretraining compute and data, combined with architecture and optimisation work, aimed at improving world knowledge, pattern recognition and what OpenAI calls intuition.

I think this split matters. We are starting to see two different kinds of model improvement that are easy to collapse into one word: intelligence.

Reasoning is visible, so we overvalue it

Reasoning improvements are easy to measure.

Give a model a difficult math problem. Let it spend more compute. Compare whether it reached the right answer. The difference between a fast model and a reasoning model can be dramatic.

OpenAI's o1 work made that explicit. The company reported that o1 performance improves as more computation is spent during training and at test time. o3-mini now exposes low, medium and high reasoning-effort settings, turning that trade-off into a developer-facing control.

This creates a strong mental model: better AI means more thinking.

But many useful tasks are not bottlenecked by explicit multi-step reasoning.

If I ask a model to recognise what kind of system I am describing, infer an unstated constraint, write in the right tone, connect two technical ideas, identify an object in an image, or notice that a proposed workflow does not fit the surrounding context, there may not be a clean reasoning chain to optimise.

The model needs a good internal representation of the world before extra reasoning becomes useful.

Pretraining and reasoning solve different problems

OpenAI now describes unsupervised learning and reasoning as two complementary scaling axes.

In its GPT-4.5 release, the company says scaling unsupervised learning improves world-model accuracy and intuition, while reasoning training improves the ability to work through difficult logic and STEM problems before answering.

The benchmark split reflects that difference.

GPT-4.5 scores 85.1% on multilingual MMLU, ahead of both GPT-4o and o3-mini in OpenAI's table. It reaches 74.4% on MMMU, improving on GPT-4o. On GPQA it reaches 71.4%, well above GPT-4o's 53.6% but below o3-mini's 79.7%.

Then AIME makes the difference obvious. GPT-4.5 scores 36.7%. o3-mini at high reasoning effort reaches 87.3%.

That is not evidence that one model is simply smarter than the other. It shows that capability depends on what kind of computation the task needs.

A model can know more and reason less. Another can know less broadly but spend much more computation manipulating what it knows.

The strongest system may need both.

Reasoning cannot recover knowledge that is not there

There is a practical limit to test-time thinking.

If the base model has a weak representation of a domain, more inference steps can produce a longer path through the same weak representation. Search and tools can compensate for missing information, but within the model itself, reasoning still starts from what pretraining has encoded.

This is why I see GPT-4.5 as more interesting than its benchmark position suggests.

OpenAI says the model has broader world knowledge, better recognition of patterns and connections, and lower hallucination on its factuality evaluations. It is designed to respond directly rather than enter the deliberate reasoning process used by the o-series.

That suggests pretraining is still buying capabilities that are difficult to reproduce by simply increasing test-time compute.

The older scaling-law work points in the same general direction. Language-model loss has historically improved predictably with model size, dataset size and training compute. Reasoning adds a new scaling axis; it does not erase the earlier one.

This matters more in production than on math benchmarks

Most software products do not receive a continuous stream of olympiad problems.

A model inside a production system has to understand vague requests, recognise entities, follow conventions, interpret incomplete information, choose tools and communicate results in a useful way.

In my own kind of work, consider a Blender automation request such as: "Export the hero product shots, keep the approved camera framing, and make sure the web versions are not using the print material setup."

There is reasoning in that task, but the hard part may be contextual understanding: what counts as a hero shot, which cameras are approved, what distinguishes the web and print material setup, and which parts of that intent sit in the prompt rather than only in project state.

A model that can solve a hard logic puzzle but routinely misreads ordinary intent is not automatically the better production model.

The same applies to game development. Debugging an algorithm can benefit from extended reasoning. Understanding a messy project convention, interpreting a designer's shorthand or recognising that two apparently unrelated errors come from the same subsystem depends on broad representations and pattern recognition as well.

This is why I would not choose models from a single intelligence ranking. I would evaluate what kind of failure dominates the actual workflow.

More intelligence may mean routing between modes

There is an interesting systems consequence here.

If pretraining and reasoning produce different strengths, the future product architecture may not need every request to pass through the most expensive reasoning process.

Some tasks need fast access to broad knowledge and strong pattern recognition. Others justify extra inference compute. A system could distinguish between them and allocate computation accordingly.

We are already seeing the beginning of that separation in model families. GPT-4.5 is described as general-purpose and compute-intensive because of its scale. o3-mini is optimised around cost-efficient reasoning, with adjustable reasoning effort.

Neither is a universal answer.

For developers, this suggests that model selection may become another scheduling problem: route work according to the kind of capability required, not just a single "best model" label.

My prediction

I do not think reasoning models replace the pretraining scaling path.

I expect the two approaches to converge.

Stronger pretrained models should give reasoning systems better internal representations to work from. Better reasoning should let those models manipulate their knowledge more effectively when a task deserves the extra compute. Tool use can add current or private information when neither training nor internal reasoning is enough.

The resulting system may have several forms of computation available: immediate pattern completion for simple tasks, longer reasoning for hard ones, retrieval for external knowledge and tools for actions.

That architecture looks more plausible to me than putting every request through maximum reasoning.

There is a cost argument too. OpenAI describes GPT-4.5 as very large and compute-intensive and explicitly says it is not a replacement for GPT-4o. Reasoning has its own latency and inference costs. Production systems will have to choose where each form of compute creates enough value to justify itself.

The last six months made inference-time compute look like a new scaling axis. GPT-4.5 is a useful correction to the temptation to turn that insight into a complete theory of model progress.

Thinking longer matters.

What the model has learned before it starts thinking still matters just as much.

Sources

1. OpenAI, Introducing GPT-4.5, 27 February 2025.
2. OpenAI, GPT-4.5 System Card, 27 February 2025.
3. OpenAI, OpenAI o3-mini, 31 January 2025.
4. OpenAI, Learning to reason with LLMs, 12 September 2024.
5. Kaplan et al. / OpenAI, Scaling Laws for Neural Language Models, January 2020.