As the artificial intelligence landscape matures, the industry is experiencing a massive transition from purely scaling pre-training compute to aggressively optimizing inference-time computation. This shift fundamentally alters the economic and architectural paradigms of machine learning. The bottom-line conclusion is clear: dynamically allocating compute during generation—enabling models to "think" before responding—yields Pareto-optimal (a state where performance cannot be further improved without degrading another variable, such as cost or speed) performance gains that rival massive parameter increases. This report establishes that smaller models leveraging advanced search strategies and Process Reward Models (PRMs) can systematically outperform much larger models relying on naive greedy decoding. For AI practitioners, the actionable recommendations are twofold: first, redirect computational budgets toward sophisticated inference pipelines (e.g., Monte Carlo Tree Search combined with PRMs) rather than exclusively relying on larger base models; and second, implement dynamic internal routing mechanisms like Mixture-of-Depths to reclaim the FLOPs required for this extensive search. The following key takeaways summarize the core mechanisms driving this revolution.

Key Takeaways:

• The Test-Time Scaling Paradigm: Empirical research confirms that dynamically allocating compute during model inference—often termed "System 2" thinking—can yield reasoning improvements that rival or exceed traditional pre-training scaling, creating a new compute-optimal frontier.
• Provable Algorithmic Guarantees: Advanced inference strategies, such as two-stage knockout tournaments, offer mathematically provable scaling laws where the probability of generating a correct solution approaches 100% as the compute budget grows.
• The Granularity Mismatch and PRMs: The shift toward inference scaling is severely bottlenecked by traditional Outcome Reward Models (ORMs). Process Reward Models (PRMs) resolve this by providing step-wise, Markovian feedback, though they introduce massive data annotation challenges.
• Implicit and Grounded Verification: Cutting-edge methodologies like Implicit PRMs, GroundedPRM, and Self-Guided Process Reward Optimization (SPRO) are successfully bypassing the need for human-annotated step-level data, relying instead on environment execution and intrinsic advantage estimation.
• Mixture-of-Depths (MoD): Complementing external test-time scaling, MoD architectures allow models to dynamically route tokens internally, skipping irrelevant layers to reduce forward-pass compute by up to 50% without degrading iso-FLOP performance.

For the past half-decade, the artificial intelligence architecture landscape has been largely dominated by a singular, unyielding philosophy: pre-training scaling laws. This approach operated on the fundamental assumption that machine intelligence is primarily a function of pattern recognition capability acquired long before a user ever types a prompt [cite: 1]. Engineers poured thousands of GPUs into massive training runs, confident that larger models trained on larger datasets would predictably yield lower error rates. However, as the limits of high-quality training data approach and the financial costs of pre-training reach astronomical heights (for instance, the training cost for OpenAI's GPT-4 is estimated at $78 million to over $100 million, while Google's Gemini Ultra 1.0 required approximately $191 million) [cite: 2, 3], the industry is undergoing a profound paradigm shift. A new frontier has emerged that challenges the supremacy of pre-training as the sole driver of capability. It is the domain of test-time compute—colloquially referred to as "letting the model think."

This comprehensive report deconstructs the mechanisms, mathematics, and architectural frameworks driving this revolution. We will explore how Inference Scaling Laws are rewriting the rules of compute optimization, why Process Reward Models (PRMs) are the critical infrastructure needed to guide this search, and how dynamic internal allocation methods like Mixture-of-Depths (MoD) are changing the very fabric of the transformer forward pass. By analyzing the theoretical underpinnings and practical implementations of these concepts, we reveal how the next generation of AI will rely less on static memorization and more on dynamic, verifiable reasoning.

The Illusion of Pre-Training Supremacy and Inference Scaling Laws

Historically, when faced with a challenging reasoning task, the standard approach was to deploy a larger Large Language Model (LLM) utilizing a standard greedy decoding strategy—where the model simply selects the most probable next token at every step. However, recent empirical studies have conclusively demonstrated that scaling inference compute via advanced generation strategies can be vastly more computationally efficient than merely scaling model parameters [cite: 4, 5].

To study how performance scales as inference compute is increased, researchers have mapped out cost-performance trade-offs across various model sizes (such as the Pythia and Llemma families) and inference strategies [cite: 4, 5]. The results consistently point to a new compute-optimal frontier of performance. Research has quantified this trade-off, finding that on challenging mathematical benchmarks (such as MATH and GSM8K), a significantly smaller model using a high-compute inference strategy can consistently outperform a model up to fourteen times its size operating on standard greedy decoding [cite: 1, 5]. For instance, baseline evaluations reveal the raw capabilities of smaller models: the Pythia 1.0B model achieves a mere 2.1% accuracy on MATH and 1.9% on GSM8K, while Bloom 1.1B hits 0.1% on MATH and 1.2% on GSM8K, and TinyLlama 1.1B scores 1.9% on MATH and 1.8% on GSM8K [cite: 6]. However, empirical data shows that the Llemma-7B model, when paired with a novel tree search algorithm, systematically outperforms the much larger Llemma-34B model across all tested inference strategies on mathematical reasoning evaluations [cite: 4]. Further research demonstrates that an advanced inference technique like continuous guided search (CGS) on a Qwen2.5-7B model can reach an astounding 81.8% on the MATH benchmark [cite: 7].

This dynamic introduces the concept of the compute-optimal inference frontier. For any given problem difficulty, there exists an optimal allocation of test-time compute. For trivial problems, allocating search budget is inefficient; generating a single response is optimal. However, for medium to highly complex reasoning problems, strategies such as generating multiple parallel samples, employing majority voting, or utilizing tree search algorithms yield the highest return on investment for the FLOPs (Floating Point Operations) expended [cite: 1, 5]. These relationships allow engineers to reason about and design compute-optimal inference configurations that extract maximum performance at a fixed compute budget, proving that smaller models combined with advanced algorithms offer Pareto-optimal (a state where performance cannot be further improved without degrading another variable, such as cost or speed) trade-offs [cite: 4, 5].

Deconstructing Provable Inference Scaling Laws

While empirical evidence of test-time scaling is robust, the academic community has aggressively pursued theoretical guarantees. We must ask: under what conditions can we mathematically guarantee that spending more compute will eventually yield the correct answer? This is encapsulated in the pursuit of provable inference scaling laws.

In this context, a provable inference scaling law is defined strictly. An LLM-based algorithm enjoys a provable inference scaling law for a specific input problem if its success probability (accounting for the inherent randomness of the algorithm) in returning a correct solution can be boosted arbitrarily close to 100% as its test-time compute grows [cite: 8, 9]. This guarantee, naturally, relies on certain identified assumptions about the problem domain and the underlying capabilities of the LLM.

To realize these provable laws, researchers have proposed algorithms that move beyond naive sampling. One of the most prominent frameworks is the two-stage knockout-style algorithm. The methodology is as follows:

• Stage 1: Candidate Generation: Given an input problem, the model repeatedly samples multiple candidate solutions. The core assumption here is that the LLM has a non-zero probability of generating a correct, strong solution [cite: 8, 9].
• Stage 2: Pairwise Knockout Tournament: The generated candidates are then aggregated and pitched against each other in a knockout tournament. The LLM acts as a judge, conducting pairwise comparisons between candidates. The theoretical requirement is that the LLM must perform better than random chance when comparing a correct solution against an incorrect one [cite: 8, 9].

The implications of this structured aggregation are profound. By separating generation from verification and forcing rigorous comparative evaluation, mathematical proofs demonstrate that the algorithm's failure probability decays to zero. Depending on the specific hyperparameter scaling (the number of initial candidates versus the depth of the tournament), the failure rate decays either by a power law or exponentially with respect to the total number of LLM calls [cite: 8, 9]. Intuitively, if the hyperparameters are sufficiently large, the algorithm will, with high probability, identify and elevate the correct solution to the final output, fulfilling the definition of a provable scaling law [cite: 9].

Overcoming the Granularity Mismatch: Outcome vs. Process Reward Models

The success of test-time compute strategies—whether through Best-of-N sampling, self-refinement, or complex tree searches—relies entirely on the system's ability to accurately evaluate the candidates it generates. If the model cannot distinguish between a flawed reasoning path and a correct one, generating additional tokens is a waste of computational resources. This introduces the critical role of reward modeling, a domain historically dominated by Outcome Reward Models (ORMs).

Early alignment and inference pipelines predominantly relied on ORMs, which evaluate an entire response and judge only the final answer [cite: 10, 11]. They produce a singular, scalar score based on the ultimate correctness of the output [cite: 12]. However, as reasoning tasks grow longer and more complex, relying on ORMs creates a severe "granularity mismatch" [cite: 13]. An ORM provides a static, outcome-centric view that struggles to capture stepwise progress, diagnose intermediate errors, or allocate computation adaptively during active generation [cite: 10].

To address this challenge, the frontier has shifted toward Process Reward Models (PRMs). A PRM is a class of models designed to provide step-wise, fine-grained evaluation and supervision to LLMs engaged in multi-step decision-making [cite: 10, 12]. By assigning reward signals to each intermediate step in a solution trajectory, PRMs explicitly assess and guide reasoning dynamically [cite: 10, 12]. To illustrate this intuitively, utilizing an Outcome Reward Model is akin to a math teacher who only looks at the final answer on an exam, assigning a pass or fail grade regardless of the student's methodology. In contrast, a Process Reward Model acts as a diligent tutor grading the granular steps of a mathematical proof, providing targeted feedback on exactly where a calculation went astray, even if the final answer is ultimately incorrect.

To fully grasp the architectural divergence between these two approaches, we can examine their characteristics systematically.

The superiority of PRMs in test-time scaling is rooted in robust mathematical frameworks. Advanced PRM designs reformulate evaluation as a deterministic Markov Decision Process (MDP). By utilizing Q-value (the expected cumulative reward or advantage of taking a specific action or step in a state) ordering and margin-based comparative losses, PRMs capture the sequential dependencies of a reasoning chain [cite: 12]. This ensures that each reward depends recursively on future step impact, offering more reliable error localization. Consequently, PRMs outperform ORMs in Best-of-N sampling, reinforcement learning pipelines, and scenarios where chain-of-thought reliability is mission-critical, establishing a new standard for explainable AI [cite: 11, 12]. Furthermore, an ideal PRM must satisfy dual-consistency objectives: Score Consistency (ensuring coherent evaluation across partial and complete responses) and Preference Consistency (aligning partial sequence assessments with human preferences) [cite: 13].

The Data Bottleneck and the Rise of Implicit PRMs

Despite their undeniable advantages in guiding inference scaling, PRMs suffer from a crippling logistical bottleneck: they are vastly more expensive (often requiring a cost multiplier of 5x to 10x per annotation) and difficult to train than ORMs [cite: 10, 14]. Because PRMs require correctness labels for every intermediate step, building effective PRMs demands costly, step-wise human annotation [cite: 10, 14]. Benchmarks designed to evaluate process rewards, such as ProcessBench and PRMBench, contain an average of 7.1 to 13.4 steps per problem, naturally multiplying the annotation workload by an order of magnitude compared to standard response-level labeling [cite: 10].

When researchers attempt to bypass human labor using LLM-based self-evaluation, the resulting supervision is often noisy, misaligned, and highly prone to hallucination [cite: 14]. This friction has birthed a massive sub-field dedicated to extracting process-level signals without the requisite step-level data, leading to the development of Implicit PRMs.

Theoretical and empirical research has recently demonstrated a breakthrough: an implicit PRM can be obtained at virtually no additional cost by simply training an ORM on cheaper, response-level labels [cite: 11]. When an ORM is trained using a specific objective (such as Direct Preference Optimization or its variants), the implicit process reward can be mathematically extracted as the log-likelihood ratio calculated over a partial response [cite: 11]. This insight reveals that the dense, step-level rewards necessary for stable reinforcement learning and effective response reranking can be inherently induced from models trained exclusively on outcomes [cite: 11].

Other implicit methodologies include pseudo-labeling intermediate steps via outcome correctness (FreePRM), employing ensemble prompting with reverse verification to produce domain-agnostic self-supervised signals (Universal PRM), or transferring reasoning knowledge directly from a pre-trained ORM to a PRM without relying on explicit human annotation (SP-PRM) [cite: 10, 13]. These techniques effectively decouple the power of test-time scaling from the prohibitive costs of manual data curation. For example, the Eurus-2-7B-PRIME model, utilizing an implicit PRM framework, achieves a 16.7% average improvement over its supervised fine-tuning (SFT) baseline and secures a 26.7% pass@1 accuracy on MATH, surpassing the baseline instruct model while requiring only one-tenth of the training data [cite: 15]. Similarly, advanced implicit variants like the Implicit Prefix-Value Reward Model (IPVRM) have boosted the average Best-of-N (BoN) score from 25.1 to 28.1 over standard Implicit PRMs on a 0.6B backbone [cite: 16].

Tree Search, Fidelity-Aware Modeling, and SPRO

To maximize the efficacy of Process Reward Models, they are frequently embedded into complex search algorithms, most notably Monte Carlo Tree Search (MCTS). This synthesis allows the model to map out vast reasoning trajectories, evaluating and pruning branches dynamically.

One notable implementation of this is ReST-MCTS* (Reinforced Self-Training via MCTS). In traditional self-training, an LLM generates responses and filters the training data based purely on correct final answers, which often inadvertently includes flawed intermediate logic—a phenomenon known as reward hacking [cite: 17]. ReST-MCTS* circumvents this by integrating process reward guidance directly with tree search. Given oracle final answers, the algorithm infers correct process rewards by estimating the probability that any specific intermediate step will lead to a correct outcome [cite: 17]. These inferred rewards serve a dual purpose: they act as value targets to continuously refine the PRM, and they facilitate the selection of ultra-high-quality reasoning traces for policy model fine-tuning. Within a controlled search budget, this tree-search policy achieves drastically higher accuracy compared to baseline Best-of-N techniques [cite: 17].

However, even advanced search algorithms are vulnerable to credit misattribution, where the system incorrectly assigns high reward to flawed logic that coincidentally reached the correct answer. To eliminate hallucinated supervision and ensure high factual fidelity, researchers introduced GroundedPRM. This framework utilizes external tools to validate intermediate steps [cite: 14]. By grounding the evaluation in execution (for example, running a block of intermediate Python code to verify its state), GroundedPRM provides execution-grounded correctness signals. This drastically reduces reward noise and ensures fine-grained credit assignment, bridging the gap between abstract neural evaluations and strict logical correctness [cite: 14]. In empirical evaluations on ProcessBench, GroundedPRM achieves a state-of-the-art average F1 score of 39.7, representing a massive 26% relative improvement over the previous best auto-labeled baseline (Math-Shepherd-PRM-7B at 31.5 F1), despite utilizing a mere 10% of the training data (roughly 40,000 samples) [cite: 18, 19]. Furthermore, when employed in a reward-guided greedy search, GroundedPRM drives policy models to an impressive 42.4% average accuracy across six rigorous mathematical benchmarks, including AMC23, AIME24, and MATH [cite: 18, 19].

Pushing efficiency even further, the industry is experimenting with removing the external PRM entirely during optimization. The Self-Guided Process Reward Optimization (SPRO) framework introduces a novel approach for Process Reinforcement Learning (PRL) that relies on intrinsic step-wise advantage estimation [cite: 20]. Rather than loading a separate, memory-intensive PRM during training, SPRO computes cumulative rewards and extracts step-wise advantages directly from the policy model's own belief updates. The results are striking: SPRO maintains higher policy entropy (promoting better exploration) while requiring only 29% of the GPU hours needed by baseline outcome-supervised methods and a mere 15% of the compute required by traditional PRM-based methods, all while achieving significantly higher test accuracy [cite: 20].

Architecting the Infrastructure: A Practical PRM Implementation

For practitioners looking to deploy test-time scaling, integrating PRM training into existing infrastructure requires specific architectural adjustments. The core differentiation is formatting the training data as stepwise supervision, where a problem is broken down, and each discrete step is given a boolean label representing correctness [cite: 21].

Modern fine-tuning libraries have adapted to support this workflow. When defining a training configuration for a PRM, the architecture relies on token classification rather than standard causal language modeling. The model is trained to predict the correct label for a given reasoning step, requiring a predefined step separator token to mark the boundaries of logic [cite: 21].

Below is an example configuration for initializing a Process Reward Model training job, utilizing an AutoModelForTokenClassification architecture.

# prm_config.yaml
base_model: Qwen/Qwen2.5-3B
model_type: AutoModelForTokenClassification
num_labels: 2
process_reward_model: true
datasets:

path: internal_stepwise_data
 type: stepwise_supervised
 step_separator: "\n\n"

max_completion_length: 2048
train_on_last_step_only: false
splt: train
val_set_size: 0.01
evals_per_epoch: 10

In this configuration, the dataset must provide an array of completions and a corresponding array of boolean labels. By setting the model type to token classification and explicitly defining the step separator, the system is forced to evaluate the localized context of each step independently. Once trained, this model serves as the verifier in a Best-of-N or MCTS pipeline, effectively unlocking the test-time scaling laws discussed previously [cite: 21].

Internal Compute Allocation: The Mixture-of-Depths (MoD) Architecture

Thus far, our analysis of test-time compute has focused on external scaling—generating more tokens, branching out via tree search, and verifying them with PRMs. However, there is a complementary revolution occurring regarding how compute is allocated internally during the forward pass of the model. Traditional transformer-based language models spread Floating Point Operations (FLOPs) uniformly across all input sequences; every token passes through every layer [cite: 22]. This is computationally rigid and vastly inefficient.

The Mixture-of-Depths (MoD) architecture solves this by allowing networks to dynamically allocate computational resources across the depth of the deep neural network, enabling selective processing of tokens within individual layers [cite: 22, 23]. At its core, MoD enforces a total compute budget by capping the number of tokens (denoted as k) that are permitted to participate in the self-attention and Multi-Layer Perceptron (MLP) computations at any given layer [cite: 22]. To understand this conceptually, consider a standard transformer block as a local commuter train that stops at every single station, forcing all passengers (tokens) to experience the same lengthy journey regardless of their destination. Mixture-of-Depths (MoD), however, operates like an intelligent transit system that dynamically routes certain passengers onto an express train skipping local stops; less complex tokens bypass heavy computational layers, while highly critical tokens receive the full, deep processing.

The mechanics of MoD routing are elegant and precise, heavily inspired by Mixture of Experts (MoE) but applied to depth rather than width.

• Learned Routing Mechanism: At each layer, every token is processed by a router that produces a scalar weight. The tokens are ranked, and the top-k weights determine the identities of the tokens that will be fully processed by the transformer block [cite: 22, 23, 24].
• Residual Bypassing: The tokens that do not make the top-k cutoff are not discarded; instead, they are passed unaltered through a residual connection [cite: 23, 25]. This attenuates computation for less relevant inputs, saving immense amounts of FLOPs.
• Static Computation Graphs: Because the capacity k is defined a priori (prior to training), the tensor sizes remain known and static. This avoids the hardware inefficiencies typically associated with conditional computation, allowing the hardware efficiency gains to be anticipated and exploited ahead of time [cite: 22, 25].

The dynamic nature of MoD means that while the sum total of compute expenditure is predictable, the allocation is highly fluid and context-sensitive at the token level. A token might skip middle layers, only to be updated via self-attention in a later layer with tokens that traversed the entire network [cite: 22, 25]. Furthermore, routing affects both forward MLPs and multi-head attention, meaning the network decides not only which tokens to update but also which tokens are available to be attended to [cite: 25]. Interestingly, empirical tests indicate that the most effective way to integrate MoD is to alternate it: stacking an MoD layer followed by a full standard transformer layer, rather than replacing every layer with an MoD block [cite: 26].

The performance trade-offs of Mixture-of-Depths are highly favorable. An MoD transformer can be tuned to achieve training loss parity with an iso-FLOP (a metric comparing models when given the exact same amount of floating-point operations or compute budget) optimal vanilla transformer while using a fraction of the FLOPs (upwards of 50% fewer) per forward pass. During post-training sampling and autoregressive generation, MoD models can be upwards of 50% faster to step, all while matching baseline performance [cite: 22, 24, 27, 28]. Conversely, for a fixed training FLOP budget, MoD allows for the training of models that perform up to 1.5% better on the final log-probability objective than their dense counterparts in an equivalent amount of wall-clock time [cite: 24, 25, 29]. By combining MoD's internal dynamic compute allocation with the external test-time search guided by PRMs, architects can compound efficiency gains across the entire inference pipeline.

How exactly does a developer serve an MoD model at inference time with dynamic tensor sizes across multiple user requests, given that current GPUs are optimized for static computational graphs? The solution lies in the strict enforcement of the capacity constraint, k. Because the capacity is defined a priori, the tensor sizes for the self-attention and MLP blocks remain entirely known and static, avoiding the severe hardware inefficiencies typically associated with dynamic conditional computation. In a production environment, if fewer tokens than k route to a block, the computational inputs are simply padded to the capacity amount. Conversely, if the routing mechanism attempts to send more tokens than the capacity allows, the excess tokens are dropped from the computation and forcefully passed through the residual connection [cite: 27, 28]. This static-graph implementation ensures that while token paths are highly dynamic, the underlying matrix operations remain perfectly dimensioned for maximized hardware utilization.

Economic and Hardware Market Impacts of Inference Scaling

The pivot from pre-training supremacy to inference-time scaling carries profound downstream economic and hardware market implications. As frontier base models become astronomically expensive to train—with subsequent generations projected to demand hundreds of millions to potentially billions of dollars in infrastructure [cite: 30, 31]—commercial viability is increasingly reliant on smaller, highly optimized models doing heavy lifting at inference time. This shift dramatically alters data center design. Since generating tokens under a test-time search paradigm (such as Best-of-N or tree search) requires massive parallel sampling, the primary hardware bottleneck transitions from sheer compute (FLOPs) to memory bandwidth and capacity, specifically the Key-Value (KV) cache [cite: 7]. In a standard Transformer, generation cost is strictly bottlenecked by the size of the KV cache; thus, scaling inference directly multiplies memory demands. To mitigate this, engineers are pioneering inference-time hyper-scaling via KV cache compression and differential attention mechanisms, such as reducing the number of Key heads (which exhibit over 95% sparsity) to drastically cut memory usage without sacrificing accuracy [cite: 6]. Furthermore, the economics of serving users transforms from a flat, predictable cost-per-token into a highly variable compute allocation model, where complex queries dynamically route to larger models or invoke extensive tree search, costing significantly more compute time but yielding higher accuracy [cite: 30]. This dynamic pricing and routing ecosystem is set to reshape the foundational business models of AI access.

Real-World Case Study: Production Deployment of System 2 Models

To move beyond theoretical frameworks and ground these scaling laws in reality, one must examine the recent commercial deployment of frontier reasoning models. A prime illustrative case study is the release of DeepSeek's R1 model and OpenAI's "o1" series. These models are explicitly designed to operate on the test-time scaling paradigm. For instance, DeepSeek-R1 is a reasoning model built atop the DeepSeek-V3 base architecture, utilizing powerful post-training reinforcement learning techniques that force the model to explore and verify reasoning trajectories before outputting a final answer [cite: 32]. By expending significantly more compute at inference—effectively generating lengthy internal chains of thought—these models achieve performance parity with vastly more expensive legacy models on complex mathematics and coding benchmarks. Crucially, this demonstrates the practical viability of the paradigm: DeepSeek managed to engineer a model that achieves frontier-level capabilities at a fraction of the historical pre-training cost by aggressively shifting the computational burden to the inference phase [cite: 32]. These production deployments confirm that "System 2" thinking is no longer an academic curiosity, but the immediate future of commercial AI infrastructure.

Synthesis and the Future of Compute-Optimal AI

The architecture of artificial intelligence is fundamentally transitioning from static, monolithic retrieval to dynamic, verifiable reasoning. The old scaling paradigm assumed that intelligence had to be rigidly baked into model weights during pre-training. The new era—characterized by Inference Scaling Laws and test-time compute—proves that allocating resources during generation can achieve Pareto-optimal breakthroughs that bypass the diminishing returns of simply adding more parameters [cite: 4].

However, scaling test-time compute is a chaotic endeavor without rigorous guidance. The transition from Outcome Reward Models (ORMs) to Process Reward Models (PRMs) represents the critical evolutionary step required to tame this chaos. By breaking reasoning down into granular, Markovian steps and evaluating the Q-value of each logical jump, PRMs provide the dense feedback necessary for sophisticated tree search algorithms like ReST-MCTS* to function [cite: 12, 17]. While the data annotation requirements for PRMs remain a daunting obstacle, the rapid development of Implicit PRMs, ground-truth execution verifiers (GroundedPRM), and intrinsic advantage estimators (SPRO) suggests that the industry will soon automate process-level supervision entirely [cite: 11, 14, 20].

Finally, as we push models to "think" longer externally, architectures like Mixture-of-Depths (MoD) ensure that they "think" smarter internally. By dynamically routing only the most salient tokens through complex attention blocks and passing irrelevant data through residual shortcuts, MoD reclaims the FLOPs necessary to fuel expansive test-time search [cite: 23, 25]. Together, these innovations are deconstructing the traditional boundaries of deep learning, proving that the future of AI capability lies not just in how much data a model has seen, but in how intelligently it allocates its compute when asked to reason.