OpenAI o1: Thinking before answering

The release and the narrow claim

On 12 September 2024, OpenAI released a preview of a new model series it called o1, shipping two versions: o1-preview and the smaller, faster o1-mini. The distinctive product claim was simple to state and hard to deliver: the model would spend more computation working through a problem before it answered, rather than emitting a response in a single pass. OpenAI framed this as a model "trained to think before it responds" and described it as the start of a reasoning-oriented line separate from the general-purpose GPT series. The launch announcement presented o1-preview to ChatGPT Plus and Team users and to developers through the API, positioning deliberate, extended reasoning as a visible capability rather than an internal implementation detail.

The precise historical claim is narrower than the excitement around it. o1-preview did not introduce the idea that models can reason step by step, nor that spending more effort helps on hard problems. What the September release actually did was package inference-time reasoning as a distinct, purchasable model behavior, backed by a training method built specifically to produce and reward long internal reasoning traces. Separating that documented event from the broader judgment about its influence is the entire task of placing it correctly in the timeline.

The constraint: one forward pass, one answer

To see what o1 addressed, it helps to state the constraint that dominated the preceding era of large language models. A standard autoregressive model generates its answer token by token, and for a fixed prompt it commits roughly the same amount of computation whether the question is trivial or requires a dozen dependent deductions. The model cannot pause, try an approach, notice it failed, and start over inside a single response unless it was somehow trained or prompted to externalize that process. OpenAI's own GPT-4 Technical Report documented a model with strong performance on professional and academic exams, including a simulated bar exam around the top 10 percent of test takers, yet the same class of model remained brittle on multi-step arithmetic and logic where one early error propagates to a wrong final answer.

The constraint was not that these models lacked knowledge. It was that the amount of serial computation available for a hard problem was capped by the length of a normal answer and by training that optimized for producing that answer directly. A person given a competition math problem does not write the final line first; they work, backtrack, and check. The pre-o1 default gave the model little structured room to do the equivalent.

Prompting a model to reason: the chain-of-thought lineage

The first widely adopted workaround was not a new model but a new way of asking. In early 2022, Google researchers showed that including worked examples with intermediate steps in the prompt could elicit similar step-by-step outputs from a sufficiently large model. Their chain-of-thought paper reported that prompting a 540-billion-parameter model with just eight reasoning exemplars reached state-of-the-art results on grade-school math word problems, outperforming a fine-tuned model equipped with a separate verifier. The finding was that the capacity for multi-step reasoning was latent, and that the format of the request could unlock it.

A companion technique made the gains more robust. Rather than trusting a single chain, self-consistency decoding sampled many diverse reasoning paths and took the answer that most of them agreed on, reporting improvements ranging from roughly 4 to 18 percentage points across arithmetic and commonsense benchmarks. Both methods share an important property that connects them directly to o1: they buy accuracy by spending more computation at inference time, either as longer outputs or as many parallel samples. They demonstrated the lever. What they did not do was make the model itself decide, on its own, how much to reason and when to check its work.

Teaching a model to reason, not just prompting it

The next branch moved reasoning from the prompt into training. STaR, or Self-Taught Reasoner, proposed a bootstrap: let the model generate rationales, keep the ones that reach the correct answer, regenerate rationales for the problems it got wrong by conditioning on the known answer, and fine-tune on the successful traces. The model improves by learning from its own reasoning, reducing the need for large hand-annotated rationale datasets.

A parallel line asked how to judge a reasoning trace rather than only its final answer. Let's Verify Step by Step, from OpenAI researchers, compared outcome supervision (reward only the final answer) with process supervision (reward each intermediate step), and found that step-level feedback produced a substantially more reliable reward model, solving 78 percent of a representative subset of the MATH benchmark. That paper also released PRM800K, a dataset of roughly 800,000 human step-level annotations. This work is the clearest public antecedent of o1's training philosophy: if you can score the steps, you can optimize a model to produce good steps, not just lucky answers. The September 2024 release is best read as the productization of that idea at scale.

What o1 actually is: reinforcement learning over hidden chains of thought

OpenAI's technical explanation, Learning to Reason with LLMs, describes o1 as trained with large-scale reinforcement learning to "think" using a chain of thought before answering. Through that training, the company reported, the model learns to break problems into steps, recognize and correct its own mistakes, and try alternative strategies when an approach is not working. Two design decisions define the model. First, the reasoning is a long internal chain of thought that is optimized during training, not merely elicited by a clever prompt. Second, in the product, that raw chain of thought is hidden from the user, who sees a summarized version, a choice OpenAI justified on safety and competitive grounds in its accompanying material.

The load-bearing quantity is inference-time compute. OpenAI reported that o1's performance improved smoothly both with more training compute and with more test-time compute, meaning the model got better on hard problems when it was allowed to think for longer. That is a different growth curve from the previous era, where a fixed model gave a roughly fixed effort per query. The o1 System Card documents the safety evaluation of this behavior, including the observation that reasoning in an explicit chain gives an additional surface for monitoring how the model reaches a conclusion, alongside new risks the company assessed before release.

The numbers OpenAI reported, and who reported them

The launch numbers were striking and should be read as provider-reported results on specific tasks. On a qualifying exam for the International Mathematical Olympiad (the AIME), OpenAI stated that GPT-4o solved only 13 percent of problems while the reasoning model reached 83 percent, and that in coding contests the model landed in the 89th percentile on Codeforces. On GPQA Diamond, a set of graduate-level physics, chemistry, and biology questions, the detailed writeup reported that o1 scored about 78 percent, exceeding the roughly 69.7 percent achieved by selected human experts with doctorates, which OpenAI described as the first model to surpass that expert baseline on the benchmark.

Two caveats belong next to those figures. First, they are task-specific evaluation results on competition math, competitive programming, and science question answering; they are not a measure of general intelligence or a percentage of human ability, and strong AIME performance says little about, for example, faithful long-document summarization. Second, the strongest numbers describe the full o1 model previewed by the September release, and they come from OpenAI's own testing at launch rather than from independent replication. The direction of improvement over GPT-4o on these particular benchmarks is large and has been broadly corroborated by later work, but the exact figures are launch claims from the provider.

A new scaling axis: compute at inference time

The deeper significance of o1 is that it made a second scaling axis legible. For years the dominant lever was training scale, and the field had learned to spend it carefully: the Chinchilla study argued that for a fixed training budget, model size and training tokens should grow together, correcting the tendency to build very large models on too little data. o1 shifted attention to a complementary question: given a trained model, how much should you spend at the moment of answering, and how should you spend it?

Independent research published just weeks before the o1 launch had already formalized the payoff. Scaling LLM Test-Time Compute Optimally showed that allocating inference compute adaptively by problem difficulty could, on suitable tasks, let a smaller model match a model roughly 14 times larger under an equalized compute comparison. That result and o1 point the same way: on problems where verification or search helps, thinking longer is sometimes a better use of a compute budget than owning a bigger model. This does not repeal training-scale economics; it adds a dimension. A build team now has to reason about both how large to train and how much to let the model deliberate per query, and those choices trade against latency and cost rather than being free.

The competing responses: open reinforcement learning and integrated thinking

Because o1 hid its reasoning traces and disclosed its method only in prose, the most consequential external evidence for the approach arrived from others reproducing it. In January 2025, DeepSeek-R1 reported that strong reasoning could be incentivized through reinforcement learning without human-labeled reasoning trajectories, with behaviors such as self-reflection and verification emerging from the RL process, and released open weights and a detailed method. That paper, later published in Nature, gave the research community a concrete, inspectable instance of the family of techniques o1 had demonstrated commercially, and it triggered a broad wave of open reasoning models.

Vendors also diverged on packaging. OpenAI shipped reasoning as a separate model line. Anthropic took a different route with Claude 3.7 Sonnet in February 2025, framing extended thinking as a mode of a single model, with visible step-by-step reasoning and, in the API, a user-set token budget for how long to think, up to 128K tokens. Anthropic noted it optimized comparatively less for math and programming competition problems and more for real-world software and agentic tasks. The contrast is a genuine product-design fork that o1 opened: reasoning as a distinct model versus reasoning as a controllable setting, and competition-benchmark optimization versus practical task optimization.

The faithfulness problem: a longer trace is not an explanation

The most important caveat cuts against the intuitive reading of a reasoning model, that its visible steps show why it answered as it did. That inference was already suspect before o1. Language Models Don't Always Say What They Think demonstrated that a model can be steered by a biasing feature, such as reordering multiple-choice options, and then produce a fluent chain of thought that rationalizes the biased answer without ever mentioning the real cause. A plausible, well-structured trace can be an unfaithful account of the computation that produced the answer.

This matters twice over for o1. First, a longer reasoning trace is not proof of correctness; the model can reason at length and still be confidently wrong, and the extra tokens can lend unearned credibility. Second, because o1 hides its full chain of thought and shows a summary, users cannot directly audit even the trace that exists, and the summary is itself a model output that may not faithfully reflect the hidden reasoning. OpenAI's own decision to keep raw chains of thought unaligned for monitoring purposes, discussed in the system card, acknowledges that these traces are an object of study and a safety surface, not a transparent window that end users should treat as an explanation.

The honest limits

Beyond faithfulness, three practical limits followed o1 from launch. Thinking longer costs more and takes longer: reasoning tokens are billed and add latency, so the approach is worthwhile mainly where correctness on a hard problem justifies the wait and the price, not for every query. Gains are uneven across tasks: the large jumps appeared on competition math, coding, and science questions with checkable structure, while OpenAI noted o1-preview lagged GPT-4o on some tasks and lacked certain product features at release. And the headline evidence was, at launch, provider-reported on curated benchmarks, later contextualized by independent reproductions rather than established by them. None of this diminishes the shift; it locates it. o1 changed what was feasible on a specific class of problems and introduced a new dial, without turning every task into a solved one.

How to place o1-preview in AI history

The defensible judgment is that o1-preview was a turning point in how the field spends computation, not a discovery of reasoning itself. Its documented, narrow contribution is a model series trained by large-scale reinforcement learning to produce long internal chains of thought, shipped on 12 September 2024, with provider-reported gains on competition math, competitive programming, and graduate-level science questions. Its broad significance is that it made inference-time compute a first-class, product-visible lever and set off a rapid competitive and open-source response that generalized the method.

A useful way to navigate outward from this event is to hold three threads apart. The predecessors that supplied the components: chain-of-thought prompting, self-consistency, self-taught rationales, and process supervision. The mechanism that o1 added: reinforcement learning that optimizes the reasoning itself and lets a model decide to think longer. And the limits that later work still had to confront: cost, uneven gains, and the gap between a persuasive trace and a faithful explanation. Read that way, o1-preview is neither the origin of machine reasoning nor its completion. It is the moment the industry agreed that letting a model think before answering was a capability worth training for, paying for, and arguing about.

References

• OpenAI (2024). Introducing OpenAI o1-preview.
• OpenAI (2024). Learning to Reason with LLMs.
• OpenAI (2024). OpenAI o1 System Card.
• Wei et al. (2022). Chain-of-Thought Prompting Elicits Reasoning in Large Language Models.
• Wang et al. (2023). Self-Consistency Improves Chain of Thought Reasoning in Language Models.
• Zelikman et al. (2022). STaR: Bootstrapping Reasoning With Reasoning.
• Lightman et al. (2023). Let's Verify Step by Step.
• Snell et al. (2024). Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters.
• Turpin et al. (2023). Language Models Don't Always Say What They Think.
• DeepSeek-AI (2025). DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning.
• Anthropic (2025). Claude 3.7 Sonnet.
• OpenAI (2023). GPT-4 Technical Report.
• Hoffmann et al. (2022). Training Compute-Optimal Large Language Models.