Can test-time scaling compound through memory consolidation into a new scaling law?

This reads the question as asking whether spending compute to consolidate memory is a *new axis* of test-time scaling — the way reasoning length and search depth already are — and whether stacking these axes amounts to a genuinely new scaling law. The corpus says the pieces for this are real, and they're starting to line up. The most direct evidence is the reframing of long context as a *compute* problem rather than a *capacity* problem: the bottleneck isn't storing more tokens, it's the compute needed to fold evicted context into fast weights during an offline 'sleep' phase — and performance keeps improving the more consolidation passes you run, following the same diminishing-returns curve as ordinary test-time scaling Is long-context bottleneck really about memory or compute?. That's the key move: consolidation isn't a fixed preprocessing step, it's a knob you can turn, and turning it harder buys you more.

What makes this look like a new scaling law rather than a one-off trick is that test-time compute keeps generalizing into fresh axes. Search budget in agentic research follows a curve *identical* to reasoning tokens — same monotonic-then-saturating shape — so 'how many times the agent searches' became its own compute dimension you can trade against reasoning Does search budget scale like reasoning tokens for answer quality? How does search scale like reasoning in agent systems?. Memory consolidation is plausibly the next such axis: a third knob alongside 'think longer' and 'search more.' And researchers are explicitly hunting for these — the frontier in test-time scaling is increasingly about shifting *when* compute happens (sleep-time, post-completion) rather than just *how much*, which is exactly the regime consolidation lives in How should test-time scaling methods be categorized and designed?.

The architectural substrate is also arriving. Titans-style neural memory modules separate fast quadratic attention from a compressed long-term store that preferentially keeps 'surprising' tokens, scaling past 2M-token contexts without the usual penalty Can neural memory modules scale language models beyond attention limits?. A consolidation-driven scaling law needs somewhere for the consolidated state to go — and that's what these modules provide. So the loop closes: spend inference compute to decide what's worth remembering, then spend more compute consolidating it into weights you can cheaply reuse later.

The sharper, less obvious point is *why* compounding might actually work here rather than just adding axes that each saturate on their own. Test-time compute and parameter scaling turn out not to be independent resources — inference compute can substitute for raw model size on hard prompts Can inference compute replace scaling up model size? — and the same substitutability shows up on the training side, where folding generated reasoning traces into pretraining yields ~3x data efficiency Can training data augmentation match test-time compute scaling benefits?. Consolidation sits exactly on that seam between inference and training: it's inference-time compute that produces persistent, training-like state. That's the mechanism by which it could *compound* rather than merely add — each consolidation pass raises the baseline the next reasoning pass starts from.

The honest caveat the corpus also supplies: more compute is not automatically smarter compute. When you control for total budget, the specific framework barely matters — snowball errors accumulate per step regardless, and gains hinge on search scope and reward reliability, not the algorithm Does the choice of reasoning framework actually matter for test-time performance?. At the agent level, ~80% of performance variance is just token spend, not coordination cleverness How does test-time scaling work at the agent level?. So a 'memory consolidation scaling law' will likely show the same shape as every other test-time curve — real gains, then diminishing returns — and the interesting question becomes how cheaply you can keep the curve climbing. What you didn't know you wanted to know: the most promising frontier isn't spending *more* at inference, it's spending it at a *different time* — offline, between turns — so the model wakes up already knowing what it figured out before.