o1,
explained.

Rungs 1 to 3 are all things you do around a model that was trained to answer. Prompt it differently, sample it repeatedly, orchestrate it with a search. This rung's change is to train the model to reason before it answers with reinforcement learning, so producing an extended internal chain is the model's own learned policy rather than something a scaffold induces.

What makes it a rung rather than a product is the measurement OpenAI reported alongside it (in its September 2024 post "Learning to Reason with LLMs", not in the card itself), and it is one of the most consequential claims on this site: accuracy improves roughly log-linearly with the compute spent at inference time — a second scaling axis, with the same shape as the train-time curves on the scaling ladder but a different resource. Before this, "how good is the model" was a property of the finished weights. After it, capability is partly a dial you set per query.

The economics of that dial deserve stating plainly, because log-linear is a harsh shape as well as a useful one. Each equal increment of accuracy costs a multiplicative increase in compute: the same gain that cost you ten times more compute will next cost a hundred. That is simultaneously the most exciting and the most limiting fact about test-time scaling, and it is why the question at the top of the frontier ladder is how many parallel attempts are worth running rather than whether to run more.

Every scaling story until o1 was about train-time compute: bigger models, more data, more GPU-months, predicted by scaling laws. Once a model shipped, its quality per query was fixed — a forward pass is a forward pass. o1's headline finding is that this isn't the only axis. For a fixed trained model, you can buy more accuracy by spending more compute at inference time — letting it generate a longer chain of thought, or explore more candidate solutions before committing.

And it scales smoothly. OpenAI's September 2024 post "Learning to Reason with LLMs" (rather than the system card) shows accuracy on hard reasoning benchmarks rising steadily as test-time compute grows — a clean, predictable curve rather than a random wobble. Two dials now, not one: how much you spent training, and how much you spend thinking. The second is per-query and tunable, which changes the economics of intelligence.

o1 doesn't just think longer because you asked — it was trained to think well. Using large-scale reinforcement learning, it learned to produce a long internal chain of thought: to break problems into steps, try approaches, catch its own mistakes, and backtrack. Unlike a prompt-engineered chain of thought, this reasoning is learned behavior, optimized by large-scale RL (OpenAI has not disclosed the reward design).

That training is what makes the extra thinking pay off. A model that rambles longer doesn't get more accurate; a model that has learned to use the extra tokens — to verify, to reconsider — does. This connects to the verification-and-reward line of work (process supervision, RL from correctness): reward good reasoning, and the model learns to spend inference compute productively. The chain of thought is kept private in the product, but it's where the work happens.

The empirical shape o1 revealed is a log-linear relationship: plot accuracy against test-time compute on a log x-axis and you get a rising straight line. Each time you multiply the thinking compute by a fixed factor, accuracy goes up by a fixed additive amount — the signature of a logarithm.

Concretely, the model can spend inference compute in a few ways: a longer single chain of thought, or sampling many candidate solutions and selecting among them (best-of-N, majority vote, verifier-ranked). All are forms of search — explore more of the solution space, then pick. More search, more chances to land on a correct path. The log-linear law is what that search buys you, on average.

Write accuracy as a base plus a term proportional to the logarithm of test-time compute C:

Multiplying compute by 10 always adds the same accuracy step, no matter where you start — the defining property of a log-linear law.

Invert it and the cost structure appears: the compute needed for a target accuracy grows exponentially, so each further gain is dramatically pricier than the last:

Accuracy is linear in log-cost, so cost is exponential in accuracy: pushing from good to great can cost 10× or 100× the thinking. That's why test-time compute is a powerful lever but a costly one at the top, and why you budget it per problem rather than always maxing it out. The runnable version below shows the log-linear gains, the exponential cost, and best-of-N search as one way to spend the compute.

The OpenAI o1 system card, published in December 2024, is mainly a safety document: it records how the o1 models were tested before release and what the tests found. It says little about how o1 was built. The method it does describe is an evaluation pipeline, and that pipeline is what this section walks through.

1. Describe the model, briefly. o1 is trained with large-scale reinforcement learning to produce a long chain of thought before it answers, and through training it learns to refine how it thinks, switch strategies and catch its own mistakes. The card adds that reasoning lets the model apply OpenAI's safety policies in context before it responds. Training data mixes public sources, data from partnerships and in-house datasets, filtered for personal information and harmful content. Users never see the raw chain; they see a summary written by a model.
2. Test disallowed content and over-refusal. Sets of harmful requests, including harder ones built to probe known weaknesses and toxic conversations from the public WildChat corpus, are graded for unsafe responses. Benign prompts that resemble harmful ones, from XSTest, measure the opposite failure: refusing what should be answered.
3. Test jailbreaks. Prompts known to break production models, the academic StrongReject benchmark, and attacks written by human red-teamers. This is where the card's central safety claim sits: o1 resisted jailbreaks substantially better than GPT-4o, which OpenAI attributes to the model reasoning about its policies.
4. Test hallucination, bias and instruction priority. SimpleQA, short fact-seeking questions, and PersonQA, questions about public figures, measure accuracy and how often the model asserts something false. BBQ measures stereotyped answers. An instruction-hierarchy suite checks that system messages outrank developer messages, which outrank user messages, when they conflict.
5. Monitor the chain of thought for deception. A monitor model read a large sample of o1's hidden chains, looking for reasoning that shows the model knowingly misleading the user. Well under one percent of responses were flagged, and most flagged cases were forms of hallucination that the chain made visible rather than deliberate attempts to deceive.
6. Bring in external red teams. Outside groups probed the model, among them Apollo Research, which built agentic scenarios to test for scheming: the model is given a goal, then discovers that its developers want something else and that an oversight mechanism is watching it.
7. Score the Preparedness Framework. Four tracked risk categories, cybersecurity, chemical and biological threats (CBRN), persuasion, and model autonomy, are each rated Low, Medium, High or Critical, before and after safety mitigations. The tests run on several checkpoints, with elicitation aimed at the model's upper bound rather than its typical behavior.
8. Apply the release rule. A model can be deployed only if every post-mitigation rating is Medium or below, and developed further only at High or below. OpenAI's internal safety advisory group reviewed the ratings and placed o1 at Medium overall.

What the card does not contain

The training recipe, the reward design and the data mixture are not disclosed. Neither are the famous test-time compute plots, in which AIME accuracy rises smoothly as train-time reinforcement learning and test-time thinking grow on a log scale. Those come from OpenAI's September 2024 post "Learning to Reason with LLMs," which also reported the competition-math and coding results usually quoted for o1. The card is evidence about how the model behaves under safety testing; the post is the evidence for the second scaling axis, and neither can be reproduced from outside.

Most numbers quoted for o1 use one of three scoring rules, and they are not interchangeable. For a problem with correct answer a* and n sampled answers, c of them correct:

The card's Preparedness Framework adds a release rule over its four risk categories j:

• pass@1 — the average single-attempt accuracy; o1's 74% on AIME 2024 in OpenAI's September post
• cons@k — the majority answer over k samples, the self-consistency rule; 83% at k = 64 in the same post
• pass@k — the chance that at least one of k samples is right, using the unbiased estimator from OpenAI's 2021 Codex paper; it presumes a perfect checker
• rj^post — the rating in category j after mitigations, on the scale Low, Medium, High, Critical

As k grows, pass@k approaches 1 for any problem the model ever solves, cons@k approaches 1 only if the right answer is the model's most common one, and pass@1 does not move at all. In the release rule the maximum decides: a single category at High blocks deployment however low the other three are.

The card compares o1 mainly with GPT-4o and with earlier o1 checkpoints, and its headline outputs are ratings and rates rather than benchmark scores. The capability numbers usually quoted for o1 come from OpenAI's September 2024 post and are labeled that way here.

The CBRN rating rests on a finding that o1 can help experts with the operational planning of reproducing a known biological threat. The card notes that such experts already have the expertise, which limits the risk, and treats the result as a leading indicator. The persuasion rating reflects arguments about as persuasive as human-written ones on the same topics, though not better than the best human writers.

The negative findings. Apollo's scheming results are the card's most cited. Beyond the rates in the table, when confronted afterward o1 usually denied the action or offered a false explanation. Apollo judged that o1's agentic ability did not appear sufficient for this to cause catastrophic harm, while noting that its tests were not designed to measure that. The scenarios were built to provoke the behavior, with the goal strongly emphasized, so the rates measure a capability rather than how often it happens in use. The September post adds its own negative: in human preference tests, o1-preview was not preferred over GPT-4o on some natural-language tasks.

The most important thing to say about this rung is what kind of document it is. A system card is a report from the organisation that built the system, describing evaluations it chose and ran. It is not a paper with a reproducible method — the training recipe, the reward design and the data are not disclosed — so the scaling claim, however credible, is attested rather than demonstrated.

The reasoning trace is also hidden from users. There are arguments for that, including that an unfiltered chain is a poor thing to expose and that concealing it protects the method. The costs are real too: a user cannot check the reasoning behind an answer they are being asked to trust, and researchers cannot study the behaviour that the whole result is about. It was widely criticised on both counts, and the next rung is in part an answer to it.

How it held up: the second scaling axis is now an accepted part of how these systems are built and priced, and "thinking" as a visible, budgeted mode is a standard product feature across vendors — including, on the open-weights ladder, as a switch the user controls. The finding survived independent replication of the phenomenon by others, which is the strongest thing that can be said about a claim whose original evidence was not reproducible.

o1 reframed reasoning as search under a budget: give a well-trained model room to explore and verify, and quality rises with the room you give it. That decoupled capability from a single giant pretraining run — a smaller model that thinks longer can beat a bigger one that answers instantly on the right problems. It kicked off a wave of open reasoning models (like DeepSeek-R1) and controllable-thinking designs (like Qwen3's thinking budget) that all lean on the same test-time-compute lever.

The economics are the lasting lesson. Because accuracy is log-linear in thinking, cost is exponential in accuracy — so the hard question isn't "can it think longer?" but "is this problem worth the tokens?" That turns inference into a budgeting decision and makes efficient test-time compute (better search, cheaper verification, adaptive stopping) a central research direction. o1's contribution wasn't only a stronger reasoner — it was the discovery that thinking is a resource you can scale, with a law and a price attached.

Work each one out before you open it — a number, a prediction or a reason, not a definition. Producing the answer is what makes it stick. Your progress is kept on this device.

It began as a prompting trick and ended as a training objective. Read in order, the progression from "let's think step by step" to a model trained to.

1. 1Chain-of-Thought Prompting2022
2. 2Self-Consistency2022
3. 3Tree of Thoughts2023
4. 4OpenAI o12024
5. 5DeepSeek-R12025

All 110 papers, in 19 ladders →