Asymmetric Capacity Allocation in Self-Refinement Pipelines
First systematic analysis of model capacity distribution in self-refinement; larger generator and refiner models improve performance, critic size less impactful.
Key Findings
Methodology
The study employs controlled experiments varying the size of generator, critic, and refiner models independently, using six sizes of Qwen3 (0.6B to 32B) and four sizes of Gemma3 (1B to 27B). Performance is evaluated across five diverse benchmarks covering reasoning, summarization, planning, coding, and story generation. For each stage, models are fixed at maximum size while the target stage varies, enabling isolation of each component’s sensitivity. Performance metrics include task-specific scores and variability ranges (∆, σ). The impact of critique is assessed by comparing pipelines with and without critique, fixing critic size at 0.6B. Statistical analysis reveals differential sensitivity, with generator and refiner benefiting significantly from size increases, while critic size has minimal effect.
Key Results
- Scaling generator and refiner models leads to consistent performance gains across all tasks, with the largest models (Qwen3-32B) outperforming smaller variants by over 10 percentage points on average. The performance range (∆) for generator and refiner exceeds 10, indicating high sensitivity, whereas critic’s ∆ remains below 3.1, showing insensitivity. Even the smallest critic (0.6B) outperforms no-critique baselines, confirming critique’s positive contribution. Larger critics detect more errors but do not translate into proportionally better refinements, suggesting limited utilization of additional critique information.
- The experiments demonstrate that resource allocation favoring larger generator and refiner models is more effective than uniformly scaling all components. Critic model size, while less impactful, still provides marginal improvements and is essential for guiding refinements. The findings challenge the conventional uniform scaling paradigm, advocating for stage-specific capacity planning to optimize performance-cost trade-offs.
- Overall, the results highlight the importance of differentiated model scaling strategies in multi-stage NLP systems, enabling more efficient use of computational resources while maintaining high performance. These insights are applicable across various tasks and model architectures, providing a foundation for future research on dynamic resource allocation and adaptive system design.
Significance
This research fundamentally shifts the understanding of resource distribution in multi-stage NLP pipelines. By quantifying the differential impact of model size on each stage, it offers a principled approach to optimize computational budgets, crucial for deploying large models in real-world scenarios. The findings facilitate cost-effective system design, enabling practitioners to allocate resources where they matter most—namely, expanding generator and refiner capacities—while keeping critic models lightweight. This addresses a long-standing challenge of balancing performance and efficiency, paving the way for scalable, high-performance AI systems capable of complex reasoning and generation tasks. The methodology and insights extend beyond NLP, informing resource allocation strategies in broader AI systems involving multi-stage processes.
Technical Contribution
The paper introduces a novel stage-wise model capacity analysis framework, systematically quantifying the sensitivity of each component in a self-refinement pipeline. It employs controlled variable experiments with multiple model sizes, providing empirical evidence that generator and refiner models benefit significantly from scaling, whereas critic models do not. The study also demonstrates that even minimal critic models outperform no-critique baselines, emphasizing critique’s role in guiding refinements. The approach combines rigorous statistical analysis with diverse task evaluations, establishing a new standard for resource-efficient multi-stage model design. It bridges the gap between theoretical scaling laws and practical system optimization, offering actionable insights for deploying large language models efficiently.
Novelty
This is the first comprehensive, systematic investigation into the asymmetric capacity allocation across stages in a self-refinement pipeline. Unlike prior work that treats model scaling as a uniform process, this study reveals stage-specific sensitivities, advocating for non-uniform resource distribution. The experimental methodology, involving multiple model families and diverse benchmarks, provides robust, generalizable insights. Its core innovation lies in demonstrating that different stages exhibit distinct scaling behaviors, challenging the conventional paradigm of uniform expansion, and proposing a targeted, efficient resource allocation strategy.
Limitations
- The experiments are limited to two model families (Qwen3 and Gemma3), which may not fully represent other architectures or training paradigms. Further validation across diverse models is needed.
- Model capacity adjustments are static; adaptive or dynamic scaling strategies could further optimize performance and resource use.
- The analysis focuses on inference-time scaling without considering training costs or deployment constraints, which are critical for real-world applications.
Future Work
Future research should explore dynamic, task-aware capacity adjustment mechanisms, possibly integrating reinforcement learning or meta-learning techniques. Extending the analysis to multi-modal and multi-task systems will test the robustness of stage-specific scaling strategies. Additionally, investigating the interplay between training costs, inference efficiency, and model size will help develop holistic resource management frameworks, making large models more accessible and sustainable in practical deployments.
AI Executive Summary
Deep Dive
Plain Language Accessible to non-experts
Imagine you’re organizing a big team project. You have three key roles: a creator who comes up with ideas, a reviewer who checks if the ideas are good, and a fixer who improves the ideas based on feedback. If you give the creator a lot of resources—like better tools and more time—they can produce much better ideas. The fixer also benefits from more resources, making the final product much better. But the reviewer doesn’t need as many resources; even a small reviewer can catch most mistakes. So, instead of giving everyone the same amount of resources, it’s smarter to give more to the creator and fixer, and less to the reviewer. This way, your team works more efficiently, producing high-quality results without wasting resources. That’s what this research found about AI models: different parts of the process need different amounts of capacity to work best.
ELI14 Explained like you're 14
Imagine you’re playing a game where you build a robot. You have three parts: one that builds the robot (the generator), one that checks if it’s working right (the critic), and one that fixes any problems (the refiner). If you give the builder a super fancy, powerful part, it can make really awesome robots. The fixer also gets better parts, so it can fix problems faster and better. But the checker doesn’t need to be super fancy; even a simple checker can find most mistakes. So, instead of spending a lot of money on all parts, you should spend more on the builder and fixer, and less on the checker. This way, your robot-building process is faster and better without wasting money. That’s what scientists learned about AI: different steps in a process need different levels of power to work best, and smart resource sharing makes everything more efficient.
Abstract
Self-refinement, typically structured as generation, critique, and revision, is a widely adopted paradigm for improving LLM generation and serves as a core mechanism in many LLM agents. While the three stages involve different cognitive demands, most existing approaches conveniently treat the model size as an implementation detail rather than a subject of study, which may lead to a waste of resources. Little work has systematically examined how model size affects each stage or whether effective self-refinement requires equally capable models for generation, critique, and revision. We present the first stage-wise model size study of the self-refinement pipeline on 5 benchmarks from different domains using 6 model sizes of Qwen3 and 4 model sizes of Gemma 3. We conclude that larger generators and refiners generally improve the pipeline, whereas an undersized refiner can even harm performance. Second, performance is highly insensitive to the size of the critic, although including even a small critic consistently outperforms omitting critique altogether. Our findings demonstrate that model capacity should not be allocated uniformly across self-refinement pipelines. Instead, different stages exhibit distinct size scaling characteristics, providing practical guidance for designing more computationally efficient multi-stage language model systems.