Try this on a friend: a bat and a ball cost $1.10 together, and the bat costs $1.00 more than the ball. How much is the ball?
Almost everyone blurts "10 cents." It feels right. It's wrong. If the ball were 10 cents, the bat would be $1.10, and together they'd cost $1.20. The real answer is 5 cents.
That gap between the fast, confident wrong answer and the slower right one is the whole story of reasoning models. And it's the thing I built Day 27 of AIFromZero around.
Two places you can spend compute
For years, the way to make a model smarter was to spend more compute at training time: bigger models, more data, longer training runs. That cost is paid once and baked into the weights.
There's a second place you can spend compute, and it's the one people slept on: inference time. Every time the model answers a question, you can let it think for longer before it commits. That's test-time compute, and it turns out you can buy a lot of accuracy with it without touching the weights at all.
A reasoning model is an LLM trained to do exactly that. OpenAI's o1 and DeepSeek's R1 are the famous examples, and most frontier models now have a "thinking" mode. Before answering, the model writes a long private chain of thought where it plans, tries an approach, checks it, and backs out if it's wrong. You usually only see a short summary of that trace, but the real work happens in there.
Watch the wrong turn get caught
The interactive demo on the page uses that bat-and-ball problem, with a slider for the thinking budget. Drag it to the left and the model has almost no room to think, so it does what we all do: it blurts "$0.10" and gets it wrong.
Drag it right and you watch the hidden reasoning grow, step by step:
- Guess: the ball is 10 cents.
- Self-check: plug it back in. Bat plus ball would be $1.20, not $1.10. That's a contradiction.
- Backtrack: drop the guess, set up algebra. Let the ball be b, then b + (b + 1.00) = 1.10.
- Solve: 2b = 0.10, so b = 0.05.
- Verify: ball 5 cents, bat $1.05, difference exactly $1.00, total $1.10. It holds.
The answer flips from wrong to right in front of you, and the reason is that the model had enough room to catch its own mistake before committing. A one-shot answer never gets that chance.
The scaling curve, and where it stops paying off
The page also plots accuracy against the thinking budget, and the shape matters. It rises steeply at first, then flattens into a plateau. The first few tokens of thinking buy huge gains. Past a certain point, extra thinking barely moves the needle, and you're paying more money and more latency for almost nothing.
That plateau is the practical heart of it. Thinking is not free. Every reasoning token is billed, and it adds to the time you wait. A reasoning model pointed at an easy question is pure waste, because you're already sitting on the flat part of the curve. The skill is spending compute only where the curve is still steep: genuinely multi-step, correctness-critical problems.
A second lever: let them vote
Thinking longer on one chain is depth. There's also breadth: sample several independent chains and combine them.
The simplest version is a majority vote, also called self-consistency. Sample N answers and take the one most of them agree on. The demo has a toggle for this. With N = 1, the single greedy sample happens to fall for the trap and answers $0.10. Bump it to N = 3 or N = 5 and the chains that got it right outvote the flukes, and the winner becomes $0.05. Same weights, compute spent sideways instead of deeper, and the wrong answer flips to right again.
How they learn to reason
The trick that makes this work is reinforcement learning on verifiable rewards. For problems where you can check the answer automatically (math results, passing unit tests, a proof that type-checks), you let the model generate many chains, reward the ones that reach a verified-correct answer, and reinforce whatever reasoning got there. No human grades each step; the correctness check is the reward.
And because running a giant reasoning model everywhere is expensive, you can distill it: harvest the big model's correct chains of thought and fine-tune a small model to imitate them. You keep most of the reasoning skill at a fraction of the cost.
Play with the slider and the vote toggle here, watch a wrong answer become right, and see exactly where the curve stops paying off:
Top comments (0)