o1 (OpenAI, 2024) is a large language model trained with reinforcement learning to produce a long internal chain of thought before answering. It is designed for hard reasoning — competition math, coding, and science — where thinking step by step and checking its work matters. Its defining property is that it gets more accurate the longer it is allowed to think, making inference-time compute a lever on quality.

Why is scaling test-time compute significant?

For years, better models mainly meant more training compute. o1 demonstrated a second, independent dial: for a fixed trained model, you can buy more accuracy by spending more compute per query. This decouples capability from a single giant pretraining run and lets you allocate effort per problem — think briefly on easy ones, at length on hard ones. It reframed reasoning as search: give the model room to explore and verify, and it solves problems a single forward pass cannot.

What is the catch with test-time compute?

Because the relationship is log-linear, returns diminish: each equal gain in accuracy costs a multiplicative jump in compute. Going from, say, 50% to 65% might take 10× the thinking, and 65% to 80% another 10× — so accuracy is roughly linear in the logarithm of cost, meaning cost is exponential in accuracy. That makes test-time compute powerful but expensive at the top end, and it is why deployments budget thinking carefully rather than always thinking maximally.

Paper Breakdowns / o1

Paper 87~10 min readOpenAI 2024worked math + runnable code

Paper Breakdown

o1,
explained.

Q: What is test-time compute scaling?

Test-time (or inference-time) compute scaling is the finding that a model's accuracy improves as you let it spend more computation at answer time — for example generating a longer chain of thought or sampling and searching over more candidate solutions. o1 showed this improvement is smooth and roughly log-linear: accuracy rises approximately in proportion to the logarithm of the test-time compute, a distinct scaling axis from the long-studied train-time compute.

For a decade, "make the model better" meant one thing: train it with more compute. o1 added a second knob nobody had turned this far — spend more compute when it answers. Let it think longer, in a private chain of thought, and it solves competition math and hard code that a single fast pass never could. The remarkable part is how orderly the gain is: plot accuracy against thinking time and you get a clean rising line on a log scale. A new scaling axis, with its own price tag. Here's the law, and what it costs.

Video breakdown

The animated walkthrough is in production.

Read the full breakdown below in the meantime ↓

Prefer video? Browse published breakdowns →

A second knob Learning to think The inference law Log-linear, and its price Run it yourself What it showed Reasoning as search

A second knob

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. o1's 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.

The one-sentence version

For a fixed model, accuracy rises roughly log-linearly with test-time (thinking) compute — a second scaling axis beyond training, powerful but with multiplicatively growing cost.

Learning to think

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 RL against whether the final answer is correct.

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 inference law

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.

Two scaling axes — and the cost of the second

Train computeThe old axis: bigger, longer pretraining → better base model.

Test computeThe new axis: think longer per query → higher accuracy, same model.

Log-linearEach ×10 in thinking buys a fixed accuracy step.

The priceSo equal accuracy gains cost exponentially more compute.

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.

Log-linear, and its price

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

A(C) ≈ A₀ + k · log(C) ⟹ A(10·C) − A(C) = k·log 10 (constant)

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:

C(A) ≈ 10^{(A − A₀)/k} ⟹ a higher target costs a multiplicative jump in compute

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.

RUN IT YOURSELF

Spend compute, buy accuracy

o1's inference-scaling law is a logarithm you can run. Accuracy is a base plus a term in log(test-time compute), so equal ×10 jumps in thinking give equal additive accuracy steps — a straight line on a log axis. Invert it and the compute for a target accuracy grows exponentially: reaching a higher bar costs a multiplicative leap. Best-of-N search is one concrete way to spend the compute — more samples, higher chance at least one is right. Change the slope, the target, or N and watch the trade-off move.

CPython · WebAssembly

# o1 (OpenAI, 2024) is trained with reinforcement learning to produce a long private chain of
# thought before answering. Its landmark finding is a SECOND scaling axis: accuracy improves
# smoothly with TEST-TIME (inference) compute -- how long it "thinks" -- roughly LOG-LINEARLY,
# on top of the usual train-time scaling. So you can trade more thinking at inference for more
# accuracy, but each equal step up in accuracy costs a MULTIPLICATIVE jump in compute.
import math

def accuracy(compute, base=0.2, slope=0.15):        # accuracy ~ base + slope*log10(test-time compute)
    return min(1.0, base + slope * math.log10(compute))

def compute_for_accuracy(target, base=0.2, slope=0.15):   # invert: compute grows EXPONENTIALLY with target
    return 10 ** ((target - base) / slope)

def pass_at_n(p, n):                                 # best-of-N search: at least one of N samples correct
    return 1 - (1 - p) ** n

print(f"accuracy at 10 / 100 / 1000 units of thinking: {accuracy(10):.2f} / {accuracy(100):.2f} / {accuracy(1000):.2f}")
print(f"equal x10 compute steps -> equal +{accuracy(100)-accuracy(10):.2f} accuracy steps (log-linear)")
print(f"compute to reach 0.5 acc: {compute_for_accuracy(0.5):.0f}, to reach 0.8 acc: {compute_for_accuracy(0.8):.0f}  (exponential)")
print(f"best-of-N with p=0.3: N=1 -> {pass_at_n(0.3,1):.2f}, N=10 -> {pass_at_n(0.3,10):.2f}")

What it showed

o1 reset the state of the art on hard reasoning and, more importantly, established a new axis to scale:

Result	Significance
Test-time compute scales accuracy	The headline: a fixed model gets better with more thinking, roughly log-linearly — a second scaling law.
Big jumps on hard reasoning	Large gains on competition math (AIME), coding (Codeforces), and graduate-level science over prior models.
RL-trained chain of thought	Reasoning is learned by reinforcement learning against correctness, not just prompted.
Safety via reasoning	The system card notes reasoning over a safety policy improved robustness — the model can "think" about rules.

The gains were uneven across task types: enormous on problems that reward search and verification (math, code), modest on tasks that don't. That's consistent with the mechanism — test-time compute helps most where a problem can be broken into checkable steps and explored, and least where the answer is a single intuitive leap.

Reasoning as search

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.

Worth knowing

The log-linear curve is an average over problems. On some, extra thinking helps a lot; on others it plateaus fast or even hurts (overthinking a simple question). Adaptive test-time compute — think more only when it pays — is the natural next step, and where controllable-reasoning models pick up.

Frequently asked

Quick answers

What is o1?

OpenAI's 2024 reasoning model, trained with RL to think in a long chain of thought before answering, whose accuracy scales with test-time compute.

What is test-time compute scaling?

Accuracy improving as a fixed model spends more compute per query (longer thinking or more search) — roughly log-linear in that compute.

Why does it matter?

It's a second scaling axis: a fixed model can get better by thinking longer, decoupling capability from a single giant training run.

What's the catch?

Log-linear gains mean exponential cost — each further accuracy step needs a multiplicative jump in compute, so thinking must be budgeted.

Finished this one? 0 / 101 Paper Breakdowns done

Explore the topic

See this alongside everything else on the same subject — handbooks, system designs, challenges and tools, in one place.

LLM Engineering

o1,
explained.

A second knob

Learning to think

The inference law

Log-linear, and its price

Spend compute, buy accuracy

What it showed

Reasoning as search

Quick answers

What is o1?

What is test-time compute scaling?

Why does it matter?

What's the catch?

Explore the topic

More Paper Breakdowns

Explore more from Vibe Engines

o1,explained.

A second knob

Learning to think

The inference law

Log-linear, and its price

Spend compute, buy accuracy

What it showed

Reasoning as search

Quick answers

What is o1?

What is test-time compute scaling?

Why does it matter?

What's the catch?

Go deeper

DeepSeek-R1 →

Let's Verify →

Qwen3 →

Explore the topic

More Paper Breakdowns

Explore more from Vibe Engines

Get the next one in your inbox.

o1,
explained.