Asymmetric Capacity Allocation in Self-Refinement Pipelines

Background and Context

Self-refinement has become one of the most widely adopted paradigms in large language model research and deployment. Its structure consists of three sequential stages: generation, in which the model produces an initial answer; criticism, in which that output is reviewed and its flaws are identified; and revision, in which the model improves its answer based on the critique. The paradigm is used not only to lift the quality of single-task generation but has been embedded as a core mechanism within many LLM agents, where it plays an important role in complex reasoning and tool-calling scenarios.

Despite this prevalence, the authors identify a problem that has been long neglected. Although the three stages impose genuinely different cognitive demands, prior research has generally treated model size as an implementation detail rather than a question worth systematic study. The authors argue that this oversight can lead to serious waste of computational resources, since capacity is frequently deployed uniformly across every stage without regard to how each stage actually benefits from it.

The central contribution of the work is therefore the first stage-by-stage, systematic investigation of model scale in self-refinement pipelines. The authors explicitly test how model size affects each individual stage and whether effective self-refinement requires the generator, critic, and refiner to be matched in capability. This question fills an important gap and lays an empirical foundation for subsequent resource-allocation design.

Deep Analysis

On the technical side, the authors built an experimental framework that covers the complete self-refinement flow. The pipeline is decoupled into generation, criticism, and revision as three independently controllable stages, allowing researchers to swap the model size used at each stage in an orthogonal fashion. This design lets the study isolate the scale effect of each stage rather than measuring only a single fixed configuration. The experiments span five datasets drawn from different domains, ensuring that the conclusions are broadly applicable rather than confined to a single task. For the models, the study selected six different sizes of Qwen3 and four different sizes of Gemma 3, forming a sufficiently wide scale gradient so that each stage's response to capacity could be observed in detail. Through enumeration of different stage-size combinations, the authors systematically measured pipeline performance under each configuration.

The results surface several counterintuitive findings. Larger generators and refiners generally keep improving overall pipeline performance, indicating that these two stages exhibit positive scaling behavior with respect to capacity. Yet an overly small refiner can actually harm performance, showing that a refiner with insufficient capacity brings no gain and may instead introduce negative effects. Pipeline performance, by contrast, is highly insensitive to the scale of the critic: results remain relatively stable regardless of which critic size is used. Importantly, even a very small critic consistently outperforms completely omitting the criticism step, demonstrating that the critique process itself holds independent value. Together these ablation findings point to a clear conclusion—self-refinement stages differ substantially in their capacity needs, and not all of them depend equally on large models.

Industry Impact

For the open-source community and industrial deployment alike, these results carry practical guidance. In terms of resource allocation, the authors argue explicitly that model capacity should not be distributed uniformly across a self-refinement pipeline. Instead, capacity should be deployed asymmetrically according to each stage's scaling behavior.

This means practitioners can use a lightweight model in the criticism stage to save compute, then reinvest those saved resources into generation and revision, the stages that are more sensitive to capacity. The result is a significant reduction in computational cost without sacrificing—and in some cases even improving—overall effectiveness. For systems that build large-scale LLM agents, such fine-grained capacity allocation helps achieve better performance within a fixed budget.

The work also challenges the common practice of deploying a single unified large model across the entire pipeline. By demonstrating that different stages exhibit differentiated scaling behavior, it provides a solid empirical basis for differentiated resource configuration and offers a new analytical lens for understanding multi-stage language model systems.

Outlook

For subsequent research, the stage-by-stage scale framework established here opens a new line of inquiry. It invites investigators to explore the interaction effects between stages and to search for even more optimal resource-configuration schemes. The authors' framework makes these questions tractable by providing a controlled way to vary capacity at each stage independently.

Overall, this work elevates model scale from an overlooked implementation detail to a variable worth actively designing. By quantifying how each stage of self-refinement responds to capacity, it supplies clear and practical principles for building multi-stage language model systems that are more compute-efficient. As agents grow more complex and deployment budgets tighter, asymmetric capacity allocation is likely to become an increasingly important design consideration rather than an afterthought.