How Test-Time Scaling Allocates Depth, Width, and Feedback in LLM Reasoning

When we talk about the reasoning capabilities of large language models, a core question is often overlooked: Given the same inference budget, why can some models delve deep along a single path, others explore multiple alternatives simultaneously, and yet others self-correct after failure? This involves the three key dimensions of Test-Time Scaling — depth, width, and feedback.

What Is Test-Time Scaling

Test-time scaling refers to a series of methods that enhance output quality by increasing computational resources during the inference phase of a model. Unlike traditional training-time scaling (increasing parameter count or data volume), test-time scaling does not alter model weights but dynamically allocates computational budget during generation.

The practical value of this concept lies in enabling the same base model to quickly answer simple questions and to allocate more computational resources for deep reasoning on complex problems. This flexibility allows inference cost to dynamically match task difficulty.

Comparison of Training-Time Scaling and Test-Time Scaling: Training-time scaling refers to enhancing a model's capability ceiling by increasing model parameters, expanding training data scale, or extending training duration, with costs concentrated in a one-time large-scale training phase, and once training is complete, capabilities are固化 in the weights. Test-time scaling, on the other hand, freezes model weights entirely and trades increased computation during inference for better output. The fundamental difference is: the former raises the model's "potential ceiling," while the latter taps into the model's "existing potential." An intuitive analogy is that training-time scaling is like giving a student a longer education, while test-time scaling is like giving an exam candidate more time to think and draft during the test.

Meaning of Inference Budget: Inference budget refers to the total computational resources a model can consume when generating a single response, typically measured by the number of generated tokens, floating-point operations (FLOPs), or inference latency. Under the framework of test-time scaling, budget is a limited, scarce resource that needs allocation — it does not grow indefinitely, so the trade-offs among depth, width, and feedback are essentially a resource allocation optimization problem.

The Three Dimensions of Inference Resource Allocation

Depth: Digging Down Along a Single Reasoning Chain

Depth scaling is the most intuitive form of test-time scaling. When generating an answer, the model is allowed a longer reasoning chain, progressively decomposing the problem, verifying intermediate steps, and correcting the derivation process.

The advantage of this approach lies in logical coherence. When a problem requires multi-step derivation — such as mathematical proofs or complex code debugging — depth scaling enables the model to "think longer" like a human. But its limitations are equally obvious: if the initial reasoning direction is wrong, deeper digging only goes further down the wrong path.

Width: Simultaneously Exploring Multiple Alternative Paths

Width scaling takes a different route. The model generates multiple candidates at each step and then selects the optimal branch through some selection mechanism. This is similar to human "brainstorming" when facing difficult problems — first diverge, then converge.

The core challenge of width scaling lies in designing the selection mechanism. How to determine which path is more likely to lead to the correct answer? Common approaches include self-consistency voting, process reward model scoring, etc. The greater the width, the higher the probability of finding the correct path, but computational cost also grows linearly.

Self-Consistency Voting: Self-consistency is a typical implementation of width scaling. The approach is to have the model generate multiple reasoning paths and corresponding answers for the same problem, then select the final answer through majority voting. The theoretical basis is: although a single path is prone to errors, if multiple independent paths reach the same conclusion, that conclusion is more likely to be correct. Self-consistency does not require additional training of a verifier and is simple to implement, but it requires sufficient diversity among paths; otherwise, the voting result degenerates into repeated confirmation of a single answer.

Process Reward Model: The Process Reward Model (PRM) differs from traditional Outcome Reward Models (ORM) that only evaluate the final answer, as it assigns a quality score to each intermediate step in the reasoning chain. This means the model can detect and eliminate erroneous branches early in the reasoning process without waiting for the entire path to complete. The advantage of PRM is denser, finer-grained signals, but training cost is also higher because correctness must be annotated for each reasoning step.

Feedback: Learning from Failures and Adjusting

The uniqueness of the feedback dimension lies in introducing iteration. After generating an initial answer, the model obtains feedback signals through external verifiers or self-evaluation, then corrects the reasoning process accordingly.

This approach is closest to human "trial-and-error learning." It does not require getting it right the first time but requires the model to have the ability to recognize errors and adjust strategies. The effectiveness of feedback mechanisms highly depends on the quality of verification signals — if the verifier itself is unreliable, feedback may introduce new errors.

External Verifiers and Self-Evaluation: Sources of feedback signals can be divided into two categories. External verifiers refer to tools or models independent of the generation model, such as compilers, unit tests, mathematical solvers, or another specialized judging model. Such signals are usually high-quality but have limited coverage, applicable only to domains with clear correctness criteria. Self-evaluation involves the model judging whether its output is correct and providing modification suggestions. This approach has broad applicability but carries a fundamental risk: if the model is capable of accurately judging whether its output is correct, it is unlikely to have made the error in the first place. This "self-evaluation paradox" makes self-evaluation often less reliable than external verification.

Different Strategy Choices Under the Same Budget

The key insight for understanding these three dimensions is: they share the same inference budget pool. Increasing depth means reducing opportunities for width exploration, and investing in feedback iteration may sacrifice the depth of a single inference.

This explains why the same inference budget can produce vastly different behavior patterns. Choosing a depth-first strategy, the model delves deep along one path; choosing width-first, the model widely explores alternatives; choosing feedback-first, the model gradually approaches the correct answer through multiple attempts.

No dimension is absolutely superior to others. The optimal strategy depends on task type:

• Mathematical proof tasks: Depth scaling is usually more effective because the logical chain needs to remain coherent.
• Open-domain question answering: Width scaling has an advantage because the answer space is vast, and diversity improves coverage.
• Code generation and debugging: Feedback mechanisms are most valuable because compilers and test cases provide reliable external verification signals.

Practical Significance of Multi-Dimensional Synergy

As cutting-edge research gradually shifts from single dimensions to multi-dimensional synergy, a more nuanced question emerges: under limited budget, how to dynamically allocate the resource proportions of depth, width, and feedback?

Some research efforts are beginning to attempt to have the model itself judge the task type and adjust the scaling strategy accordingly. This adaptive allocation strategy may be the key path to more efficient reasoning systems. After all, a truly intelligent system should not exert equal effort on all problems but should, like a human expert, know when to think deeply, when to cast a wide net, and when to humbly accept feedback.

The essence of test-time scaling is endowing models with the metacognitive ability to "think about how to think" during inference. The three dimensions of depth, width, and feedback constitute the coordinate system of this metacognition. Understanding their trade-offs is a prerequisite for designing efficient reasoning systems.

One-line Summary

Test-time scaling's inference budget can be allocated across depth, width, and feedback, with the optimal strategy depending on task type.

Paragraph Summary

This article systematically elaborates on the three key dimensions of test-time scaling: depth, width, and feedback, pointing out that they share the same limited inference budget pool, thus exhibiting trade-off relationships. Depth scaling digs down along a single reasoning chain, suitable for logically coherent multi-step derivations but lacking directional error correction; width scaling improves coverage by simultaneously exploring multiple alternative paths, with its core challenge being the design of the selection mechanism; feedback scaling introduces iterative correction, with effectiveness highly dependent on the quality of verification signals. The article further points out that different task types correspond to different optimal strategies: mathematical proofs favor depth, open-domain QA favors width, and code generation favors feedback. The future direction is to let models adaptively judge task types and dynamically allocate resource proportions across the three dimensions.