Spending more compute at inference time splits into two strategies — train the model to reason, or bolt on verification afterward.

This explores the recurring throughlines that connect two bodies of work — methods for spending more compute at inference time (test-time scaling) and the designs that make models reason — and what those bodies of work, read side by side, reveal about each other. The first pattern is a clean organizing split: test-time scaling divides into *internal* methods (training a model to reason on its own) and *external* methods (search and verification bolted on at inference). They complement rather than compete — internal builds capability, external extracts performance from capability that already exists How do internal and external test-time scaling compare? How should test-time scaling methods be categorized and designed?. The most interesting recent moves don't just turn the compute dial up; they change *when* compute happens — sleep-time precomputation, post-completion refinement, recursive language models — sidestepping the usual scaling tradeoffs.

The second pattern is a surprising universality in the scaling curves themselves. Search budget in agentic deep-research systems follows the *same* diminishing-returns curve as reasoning tokens — every extra search step behaves like every extra chain-of-thought token Does search budget scale like reasoning tokens for answer quality? How does test-time scaling work for individual research agents? Do search steps follow the same scaling rules as reasoning tokens?. This reframes search as just another inference-compute axis you can trade against reasoning. The same logic scales up to multi-agent systems, where roughly 80% of performance variance turns out to be a function of total tokens spent, not coordination cleverness How does test-time scaling work at the agent level?. And the framework you pick matters less than you'd think: best-of-N and tree search converge once you hold total compute constant, because errors snowball per step regardless of algorithm — what saves you is search scope and reward-function quality, not the name of the method Does the choice of reasoning framework actually matter for test-time performance?.

But here's the tension that makes the two literatures speak to each other. Compute is not a free substitute for training. A non-reasoning model cannot catch a reasoning model no matter how much inference budget you hand it, because training instills a *protocol* that makes the extra tokens productive in the first place Can non-reasoning models catch up with more compute?. So the scaling curves only bite for models trained to climb them — which sends you straight into the critiques of what the reasoning actually is.

And those critiques are unsparing. Chain-of-thought degrades predictably the moment you step outside the training distribution — it imitates the *form* of reasoning without the underlying logic Does chain-of-thought reasoning actually generalize beyond training data? Why does chain-of-thought reasoning fail in predictable ways?. The sharpest evidence: logically *invalid* chain-of-thought prompts perform nearly as well as valid ones, which means the structural shape of the reasoning — not its correctness — is doing the work Does logical validity actually drive chain-of-thought gains?. Reasoning models also fail in a way that looks less like running out of compute and more like disorganization: they wander down invalid paths and abandon promising ones too early, and cheap decoding-level nudges fix it without any retraining Why do reasoning models abandon promising solution paths?.

Put the patterns together and a single shape emerges. More compute reliably buys you more performance along several interchangeable axes — but only inside a model trained with a real reasoning protocol, and only up to the point where structure, not validity, runs out. The frontier in the corpus isn't 'scale harder'; it's changing *when* the compute lands and making the reasoning itself less of a pattern-matched imitation. That's the thing worth knowing: test-time scaling and reasoning architecture are the same problem viewed from two ends — one asks how much thinking, the other asks whether it's thinking at all.