Test-Time Compute: Buying Intelligence by the Second

Picture two chess players given the same position. One is a grandmaster who must move in a single second, by reflex, with no time to calculate. The other is merely strong, but has twenty minutes on the clock, enough to look three moves ahead, try a line, notice it loses a piece, and back out. Give the second player enough time and they will often beat the first. The skill in their head did not change. What changed was how long they were allowed to think.

That is the whole idea behind test-time compute, and it quietly rearranged how the field thinks about intelligence in 2025. For years the only knob that mattered was size: more parameters, more training data, more compute spent once, before the model ever met a user. The result was a fixed object that answered every question, trivial or brutal, with the same instant reflex. The bet of the last year is that you can take some of that spending and move it to inference, to the moment of the question itself, and let the model think longer.

The trade

A reasoning model does not just emit an answer. Before it speaks, it generates a long internal chain of intermediate tokens: a worked solution, a draft, a private argument with itself. Those tokens are compute. More of them is more thinking. And it turns out you can spend that compute in place of model size. In a 2024 result from Berkeley and Google DeepMind that set the tone for everything after, a smaller model given extra time to reason outperformed a model roughly fourteen times larger that had to answer immediately, on easy and medium problems, at matched compute. The capability was not stored in the weights. It was bought at the moment of asking.

Size is intelligence you paid for once and froze. Test-time compute is intelligence you rent, per question, at the second you need it.

There are two directions to spend in. You can go longer: one chain of reasoning that runs deeper, reflects, catches its own mistakes, and revises. Or you can go wider: sample many independent attempts in parallel and then decide between them. The simplest way to decide is a vote: generate the solution dozens of times and take the answer that comes up most often, on the theory that the truth is a stable attractor while errors scatter. That is self-consistency, and it works surprisingly well for problems with a single checkable answer.

Search needs a judge

Voting is blunt, because the popular answer is not always the correct one. The sharper move is to add a verifier, a second model trained to score how good a candidate solution is, and let it guide the search. Now the system can grow a tree of partial reasoning, score each branch, prune the dead ones, and pour its remaining budget into the lines that look most promising. This is where small models claw back the most ground against large ones: not by thinking randomly for longer, but by thinking selectively, steered by something that can tell a good step from a bad one.

Plot all of this and a new scaling curve appears, and it is the one worth memorizing. On the horizontal axis, tokens spent thinking. On the vertical, accuracy. The line rises steeply at first: the first burst of reasoning is enormously valuable, the difference between a reflex and a glance ahead. Then it flattens. The curve is roughly log-linear: each new doubling of thinking buys a constant, shrinking slice of accuracy. You are always climbing, but the slope keeps easing toward the floor.

The first thousand tokens of thought are worth more than the next ten thousand; the curve rewards starting to reason far more than it rewards refusing to stop.

Paying by difficulty

This changes the economics in a way that is easy to miss. Under the old regime every query cost the same: one forward pass, one price. Now the cost of an answer scales with how hard you let the model work on it, and hard problems are where the long thinking pays off, while easy ones are where it is pure waste. So the meaningful unit of cost is no longer the query. It is the difficulty of the query. You are, for the first time, paying per problem in proportion to what the problem actually demands.

Which is exactly why models grew an effort dial. Through 2025 and into 2026 the labs exposed it directly: a reasoning-effort setting of low, medium, or high, or an adaptive mode that picks the budget itself by reading the task. The savings from getting this right are not marginal: an adaptive setting can cut a simple classification from sixteen thousand thinking tokens to one thousand without touching quality. Adaptive effort is not about thinking less everywhere. It is about moving the thinking off the questions that do not reward it and onto the ones that do.

Because more thinking is not free in capability either. Models overthink. Ask an o1-style model what two plus three is and it may generate a paragraph of deliberation to reach the answer a child says instantly, burning tokens, adding latency, and occasionally talking itself out of a correct first instinct. Past a point the extra reasoning stops climbing the curve and starts wandering. Knowing when to stop is itself part of the intelligence, and it is the part the dial is trying to automate.

This is the reasoning behind how EINAI routes effort per task rather than spending a flat maximum on everything. A reply that needs a fact gets answered like a reflex. A problem that needs a proof gets the clock. The model underneath is the same; what differs is how long it is allowed to think before it speaks, which, it turns out, is most of what we ever meant by thinking at all.