HeavySkill: Heavy Thinking as the Inner Skill in Agentic Harness

ArXiv: 2605.02396

🎯 Pitch

Simply asking a strong LLM to think in parallel threads and then summarize outperforms complex multi-agent orchestration, with frontier models achieving nearly theoretical Pass@N performance. Crucially, this 'heavy thinking' skill itself improves with reinforcement learning, suggesting LLMs can internalize sophisticated reasoning strategies rather than relying on brittle external frameworks.

1. Executive Summary

This paper proposes HEAVYSKILL, a perspective that abstracts the complex orchestration of multi-agent harnesses into a minimal two-stage pipeline—parallel reasoning followed by sequential deliberation—and distills it into a readable skill document that any sufficiently capable LLM orchestrator can execute. Across STEM benchmarks (AIME25, BeyondAIME, HMMT25-Feb, GPQA-Diamond) and general reasoning tasks using models from 7B to frontier scale (GPT-5-Thinking, Kimi K2 Thinking, DeepSeek R1-0528), heavy thinking consistently outperforms traditional Best-of-N strategies, with the aggregate performance (Heavy-Mean@K) frequently exceeding majority voting and, in frontier models, approaching the theoretical Pass@K upper bound by synthesizing cross-trajectory insights not present in any single reasoning path. The paper further demonstrates that reinforcement learning from verifiable rewards can optimize both the breadth (parallel generation) and depth (deliberation) of this inner skill, establishing that test-time compute scaling through heavy thinking provides systematic gains across difficulty levels while remaining fundamentally bounded by the base model's intrinsic capability on the hardest problems.

2. Context and Motivation

The Core Problem: What Actually Drives Performance in Agentic Orchestration Frameworks?

The paper addresses a fundamental opacity in the current landscape of LLM-based agent systems. Over the past several years, the field has converged on a dominant architectural paradigm: orchestration frameworks that coordinate multiple specialized agents—each with its own memory, skills, and tool access—through a central orchestrator model. Prominent examples include Claude Code (Claude), CodeX (Chen et al., 2021), OpenClaw (OpenClaw, 2024), and Hermes (Hermes-Agent, 2024). These systems have demonstrated remarkable success on complex reasoning tasks that resist solution by single-pass LLM inference. However, the paper argues that this success has been achieved at the cost of conceptual clarity:

"the underlying mechanism that truly drives performance remains obscured behind intricate system designs."

This is the paper's central diagnostic: we do not know which elements of these elaborate orchestration architectures are responsible for their gains. Are the benefits coming from the multi-agent structure itself (different roles, different prompts, inter-agent communication protocols), from the skill libraries and memory retrieval mechanisms, from the iterative refinement loops, or from something more fundamental? Without an answer to this question, the field is accumulating increasingly complex system designs without a principled understanding of what components are necessary, what are incidental, and what are merely accidental accretions of engineering convenience.

The paper's ambition is to cut through this complexity by identifying a minimal execution unit—what it calls "heavy thinking"—that can be isolated, studied independently, and ultimately internalized within the model rather than embedded in external scaffolding. If the core driver of orchestration performance can be reduced to a simple two-stage pipeline (parallel reasoning then sequential deliberation), then the elaborate agent harness may be, in an important sense, dispensible for many tasks.

Why This Matters: From System Complexity to Capability Internalization

The opacity of current orchestration systems has consequences that extend beyond academic tidiness. The paper identifies three interconnected motivations for deconstructing agentic harnesses into their essential cognitive mechanisms:

1. Architectural fragility. Multi-agent orchestration frameworks are brittle artifacts of prompt engineering and system design. They depend on carefully crafted handoff protocols, role specifications, and context management strategies that must be tuned per-application and per-model. When performance degrades—as it often does on out-of-distribution queries or edge cases—the failure can originate in any of dozens of interacting components, making systematic debugging nearly impossible. Isolating the core cognitive operation (heavy thinking) and demonstrating that it can be activated without the full orchestration infrastructure would provide a more robust foundation.

2. The inference cost—capability tradeoff. Orchestration frameworks consume enormous test-time computation: they spawn multiple agents, maintain state across rounds, and perform iterative refinement. This cost is paid regardless of whether the specific orchestration mechanisms are actually contributing to solution quality. If the essential operation is simply parallel sampling plus a synthesis step, then elaborate multi-agent architectures may be over-engineered for many problems, burning compute on coordination overhead rather than reasoning. A precise understanding of the minimal effective recipe enables cost-optimal allocation of inference budgets.

3. The path to internalization. The paper's central thesis—stated directly in its title—is that heavy thinking is not merely a test-time strategy but an inner skill that can be trained into model parameters through reinforcement learning from verifiable rewards (RLVR). From this perspective, orchestration frameworks represent an externalization of a capability that could, in principle, be internalized:

"we propose HEAVYSKILL, a perspective that views heavy thinking not only as a minimal execution unit in orchestration harness but also as an inner skill internalized within the model's parameters that drives the orchestrator to solve complex tasks."

If models can be trained to perform the parallel-reasoning-then-deliberation pattern autonomously—without external orchestration code managing the spawning, routing, and aggregation—the result would be more robust, more portable, and more efficient than current orchestration frameworks. The paper's RLVR experiments (Section B, Appendix) represent an initial step toward this internalization, and the readable skill format (Section 2.4) serves as an intermediate representation: a compact, transferable specification that any capable orchestrator can execute, demonstrating that the pattern is capability, not code.

Where Prior Approaches Fall Short

The paper positions its contribution against three distinct but overlapping strands of prior work, identifying specific gaps in each.

Prior work 1: Multi-agent orchestration frameworks (the outer harness). Systems like Claude Code, CodeX, Hermes, and OpenClaw provide powerful but opaque performance:

"the underlying mechanism that truly drives performance remains obscured behind intricate system designs."

These frameworks bundle together role decomposition, inter-agent communication, skill libraries, memory management, tool routing, and iterative refinement into complex system-level artifacts. The paper does not dispute that these systems work—they demonstrably do—but argues that the field lacks an analytical decomposition of which mechanisms are essential. Without such decomposition, improvements are ad hoc: better prompts, more agents, more tools, more memory. There is no systematic framework for understanding when multi-agent orchestration helps versus when a simpler strategy suffices, or for predicting how gains will scale with additional components.

Prior work 2: Parallel reasoning as test-time scaling (thinking in width). Recent work has explored various mechanisms for generating multiple reasoning trajectories in parallel and aggregating them. The paper identifies several sub-approaches within this category:

• Brute-force parallel sampling with end-stage aggregation: Approaches like those of Brown et al. (2024), Zheng et al. (2025b), and Wen et al. (2025) generate multiple independent solutions and select among them (via majority voting, verifier scoring, or best-of-N weighted selection). These methods treat parallel trajectories as independent draws from the model's distribution and apply a post-hoc selection rule. The paper's critique is that these methods lack synthesis: they select or vote among existing outputs but do not produce genuinely new insights from comparing trajectories.

• Inline parallel thinking tags: Methods like Group Think (Hsu et al., 2025) and others (Zheng et al., 2025b; Wen et al., 2025) modify the model's internal reasoning format to produce multiple thinking trajectories within a single generation, separated by special tags, followed by a summary phase. These approaches embed parallelism into the model's token generation rather than orchestrating it externally. However, the paper argues that their branching and merging points are dictated by static, pre-defined formatting conventions rather than being adaptive to the evolving progress of the reasoning process.

• Tree-based search methods: Monte Carlo Tree Search (Zhang et al., 2024a) and Tree of Thoughts (Yao et al., 2023) provide more granular parallelization by dynamically deciding where to branch and where to prune based on intermediate evaluation signals. However, the paper notes that these methods "remain tethered to hand-crafted heuristics and external verifiers," making them fragile and dependent on the quality of the evaluation function.

The common limitation across all these approaches is that they implement parallel generation without genuine deliberation. They produce multiple outputs and then select, vote, or heuristically merge—but they do not equip the model to understand why trajectories differ, synthesize partial insights across trajectories, or re-derive answers when all parallel attempts are wrong. The paper's sequential deliberation stage is designed to fill precisely this gap.

Prior work 3: Heavy thinking in recent frontier models. The paper acknowledges that the specific pattern of "parallel reasoning then deliberation" has begun to emerge in frontier model releases—specifically citing Gemini (DeepMind, 2025), Kimi K2 (Bai et al., 2025), and PaCoRe (StepFun-AI, 2025)—which "have demonstrated promising results by decomposing heavy thinking into two distinct stages." However, these implementations are typically:

• Undocumented in mechanistic detail: Technical reports describe the existence of a two-stage process but do not provide systematic ablation studies showing which components contribute to performance, how the stages interact, or what the scaling properties are.
• Tied to specific model architectures: There is no demonstration that the pattern transfers across model families, scales, and tasks.
• Not studied as a learnable skill: Prior work treats heavy thinking as an inference-time strategy to be executed, not as a capability to be internalized through training.

The paper's explicit goal is to move from "this pattern exists in frontier systems" to "here is a systematic empirical characterization of how and why it works, across diverse models and tasks, with a path toward internalization through RLVR."

How This Paper Positions Itself

The paper positions itself as filling a specific analytical gap in the literature. It is not proposing an entirely new inference algorithm—the two-stage pipeline (parallel reasoning + deliberation) is acknowledged as emerging independently in multiple systems. Rather, the paper makes three distinct contributions that collectively transform this pattern from an observed phenomenon into a studied capability:

1. Decomposition and systematization. The paper provides the first detailed, reproducible description of the parallel-reasoning-to-deliberation pipeline as a general inference framework, including the serialized memory cache mechanism (Section 2.2), the iterative deliberation extension (Section 2.3), and the distillation into a portable readable skill (Section 2.4). This moves the pattern from the "system design" layer (where it is entangled with orchestration infrastructure) to the "cognitive mechanism" layer (where it can be studied independently).

2. First comprehensive empirical characterization. The paper claims to be "the first to conduct the comprehensive empirical study to exhibit the performance of heavy thinking across diverse model scales and task domains." The experiments span:

• Model scales: From 7B distilled models (R1-Distill-Qwen-7B) to frontier models (GPT-5-Thinking, Kimi K2 Thinking, DeepSeek R1-0528).
• Task domains: STEM (AIME25, BeyondAIME, HMMT25-Feb, GPQA-Diamond), coding (LiveCodeBench), general reasoning (Arena-Hard, IFEval, IMO Answer Bench).
• Mechanisms within heavy thinking: Ablation of parallel trajectory selection strategies (Appendix A), cross-model pairing for reasoning vs. deliberation (Section 4.2), iterative deliberation depth (Section 4.3), and tool-interleaved heavy thinking (Section 4.4).
• Training integration: Initial RLVR experiments demonstrating that heavy thinking can be optimized through reinforcement learning (Appendix B).

3. The internalization thesis. The paper's most forward-looking claim is that heavy thinking is an inner skill—something that can exist as a learned capability within model parameters rather than as external orchestration code. The RLVR experiments in Appendix B are preliminary but directional:

"Our findings demonstrate that RLVR can also substantially improve the model's reasoning capabilities."

The readable skill format (Section 2.4) serves as an intermediate step: it demonstrates that the heavy thinking pattern is sufficiently well-specified that it can be described in natural language and executed by an LLM orchestrator without framework-specific code. This portability is presented as evidence that the pattern is capability, not infrastructure—and therefore amenable to internalization through training.

The paper draws a clear intellectual lineage: agentic orchestration → heavy thinking as the core mechanism → readable skill as the portable specification → RLVR as the path toward internalized capability. This framing reframes the paper's contribution from "another test-time scaling method" to "a perspective on what the next generation of reasoning models should natively support."

3. Technical Approach

3.1 Reader Orientation

This paper describes a training-free, two-stage inference pipeline that amplifies an LLM's reasoning capability by having it first generate multiple independent solutions to a problem in parallel, then feeding those solutions as context to a second reasoning pass that synthesizes them into a single improved answer. The system solves the problem of extracting maximal reasoning performance from a fixed model without retraining by decomposing what multi-agent orchestration frameworks do—spawn sub-agents, collect their outputs, deliberate—into a minimal, reproducible pattern that can be executed by any sufficiently capable LLM, either through external orchestration code or as a self-contained "readable skill" that the model reads and follows itself.

3.2 Big-Picture Architecture (Diagram in Words)

The system has five major components connected in a strict sequential pipeline:

1. User Query (Input): A natural-language problem—mathematical, coding, or general reasoning—that requires complex multi-step reasoning to solve.

2. Parallel Reasoning Stage: A single LLM (denoted $\pi_\theta$) is prompted $K$ independent times with the same query, producing $K$ complete reasoning trajectories $\{y_1, ..., y_K\}$. Each trajectory contains the model's full chain-of-thought and final answer. Critically, these $K$ generations are independent—no trajectory sees any other trajectory's content during generation.

3. Serialized Memory Cache: The $K$ trajectories are formatted into a single structured text block (a "serialized context") that becomes the input to the next stage. Trajectories within the cache are shuffled to prevent positional bias, and pruned if the total length would exceed the model's context window.

4. Sequential Deliberation Stage: A second LLM (denoted $\pi_\phi$, which may be the same model or a different one) receives the memory cache as input and is prompted to critically analyze all $K$ trajectories—comparing their approaches, identifying logical errors, assessing where they agree and disagree—and produce a synthesized final answer. This is fundamentally a meta-reasoning step: the model reasons about reasoning.

5. Final Output: The deliberation model outputs its synthesized answer, formatted according to domain conventions (e.g., \boxed{} for mathematics, code blocks for programming).

Information flow: Query → parallel independent generations → serialized cache of trajectories → deliberation model reads cache → deliberation model produces synthesized answer. There is an optional iterative deliberation loop (Section 2.3) where the deliberation output is appended to the cache and the deliberation model re-reads the augmented cache for a second (or third, or fourth) pass.

Crucial design choice: By default, $\pi_\theta = \pi_\phi$—the same model is used for both stages. This means no additional model training, loading, or infrastructure is required. The entire pipeline operates as a prompting and generation strategy applied to a standard LLM.

3.3 Roadmap for the Deep Dive

I will explain the components in the order they execute at inference time, building up from the simplest element to the full pipeline:

• First, the Parallel Reasoning Stage (§3.4.1): How $K$ independent trajectories are generated, what configuration is used, and what the output looks like. This establishes the "raw material" that deliberation works with.

• Second, the Serialized Memory Cache (§3.4.2): The formatting, shuffling, and pruning protocol that bridges the two stages. This is the critical interface—understanding it explains why the pipeline works across different context lengths and model scales.

• Third, the Sequential Deliberation Stage (§3.4.3): The deliberation prompt design, what the model is instructed to do (analyze, compare, synthesize, potentially re-derive), and how the final answer is extracted. This is the intellectual core of the method.

• Fourth, Iterative Deliberation (§3.4.4): The optional loop mechanism, its motivation (mimicking human iterative refinement), and its formal specification.

• Fifth, the Readable Skill Format (§3.4.5): How the full pipeline is distilled into a natural-language document that an LLM orchestrator can read and execute autonomously. This represents the bridge from "external pipeline code" to "internalized capability."

• Sixth, Key Hyperparameters and Configuration (§3.4.6): A consolidated reference of all numbers, settings, and defaults—temperature, $K$, iteration count, etc.—and the rationale for each choice.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily an empirical analysis and framework paper whose core technical contribution is a specific inference-time protocol—parallel reasoning followed by sequential deliberation—that is formalized, systematically evaluated across models and tasks, and distilled into a portable, self-contained specification. The technical novelty lies not in inventing a new algorithm (the paper acknowledges that this pattern has emerged independently in frontier systems) but in isolating the pattern from orchestration infrastructure, providing the first rigorous characterization of its behavior, and demonstrating its transferability and trainability.

3.4.1 The Parallel Reasoning Stage: Generating Raw Material for Deliberation

The parallel reasoning stage is the generation phase of the pipeline. Its sole purpose is to produce $K$ complete, independent reasoning trajectories for the same input problem, each containing the model's full chain-of-thought and a final answer. This stage operates as a pure sampling procedure—there is no selection, no pruning, no inter-trajectory communication, and no adaptation based on intermediate results.

Formal specification. Given a problem $q$ (a natural-language query), the parallel reasoning stage invokes the LLM $\pi_\theta$ $K$ times with independent sampling, producing:

$T_{\pi_\theta}(q, K) = \{y_1, y_2, ..., y_K\}$

where $K$ is the number of parallel trajectories, $\pi_\theta$ is the LLM used for generation, and each trajectory $y_i$ is a sequence of tokens:

$y_i = \{\pi_\theta(y_{i,j} \mid q, y_{i,<j})\}_{j=1}^{|y_i|}$

This notation means: for each trajectory $y_i$, the model generates tokens one at a time, where each token $y_{i,j}$ is sampled from the model's distribution conditioned on the original query $q$ and all previously generated tokens in that trajectory $y_{i,<j}$. The key property is that $y_i$ does not condition on any $y_{i'}$ for $i' \neq i$—the trajectories are mutually independent.

What this computes: It generates $K$ separate attempts to solve the same problem, each from scratch. The output is a set of $K$ complete solutions, each containing internal reasoning (chain-of-thought, intermediate calculations) and a final answer in some format. These $K$ trajectories constitute the "raw material" that the deliberation stage will analyze.

Why this form: Independent parallel sampling serves two purposes that are essential for the downstream deliberation to be effective. First, it provides diversity: different sampling paths explore different solution strategies, different intermediate steps, and different final answers. The deliberation model can only synthesize across trajectories if those trajectories contain meaningful variation—if all $K$ trajectories were identical (deterministic greedy decoding), there would be nothing to deliberate about. Second, it provides a signal about difficulty: the distribution of answers across the $K$ trajectories (how many agree, how many are unique, what the pass rate is) carries information about how hard the problem is for this model, which the deliberation model can implicitly exploit. The paper explicitly sets temperature to 1.0, top_p to 0.95, and top_k to 10 to encourage this diversity.

Configuration details. The paper uses $K \in \{8, 16\}$ in the main experiments. The generation parameters are fixed: temperature = 1.0, top_p = 0.95, top_k = 10. These are standard high-diversity sampling settings that encourage exploration of the model's output distribution rather than converging on the single most likely token at each step. The choice of $K = 8$ or $K = 16$ represents a practical tradeoff: enough trajectories to provide meaningful diversity for deliberation and to enable statistical phenomena like majority-vote signals, but not so many that the serialized cache exceeds context window limits or makes the inference cost prohibitive.

The role of the prompt in parallel reasoning. Each of the $K$ generations uses a standard problem-solving prompt, not a specialized "think in parallel" instruction. The paper does not specify the exact prompt text in the main methodology section, but the implication is clear from the skill file (Figures 8–10 in Appendix C): each parallel agent receives the problem and instructions to "solve the given problem step by step from scratch" and "show complete reasoning chain." The model is not told that it is part of a multi-trajectory system—from its perspective, it is simply answering the question independently. This is deliberate: the parallelism is an orchestration-level property, not a prompt-level property. The model does not need to know it is being sampled multiple times; the deliberation stage handles the meta-cognition.

Relationship to evaluation metrics. The parallel reasoning stage yields the raw data for several baseline metrics reported in the paper's experiments. Mean@K (denoted M@K) is the average accuracy across the $K$ trajectories: what fraction are individually correct? Pass@K (denoted P@K) is the proportion of queries for which at least one of the $K$ trajectories is correct—this measures the upper bound of what the model could achieve if it always selected the correct trajectory. Vote@K (denoted V@K) is the accuracy of the majority-vote answer: take the most common final answer across the $K$ trajectories, which is equivalent to Best-of-N with majority voting. These three metrics establish the baseline performance hierarchy against which heavy thinking (Heavy-Mean@K and Heavy-Pass@K) is compared.

3.4.2 The Serialized Memory Cache: Bridging Parallel Generation and Deliberation

The memory cache is the interface between the two stages. It transforms the $K$ independent trajectories into a single, structured text block that the deliberation model can read as its input. Without this mechanism, the deliberation model would have no way to access the parallel trajectories—it cannot "see" the outputs of other generation calls natively.

Formal specification. After the parallel reasoning stage produces $T_{\pi_\theta}(q, K)$, a formatting function $C(\cdot)$ serializes these trajectories into a context block:

$x_c = C(T_{\pi_\theta}(q, K))$

where $x_c$ is the serialized cache—a single text string—that serves as the input to the sequential deliberation stage. The deliberation model then generates:

$T_{\pi_\phi}(x_c, K^{(1)})$

where $\pi_\phi$ is the deliberation model and $K^{(1)}$ is the number of summary outputs to generate from the deliberation stage (set to 4 in the main experiments).

What this computes: It takes a set of $K$ complete reasoning trajectories—each potentially thousands of tokens long, containing interleaved reasoning and answer content—and formats them into a single prompt that the deliberation model can process. The formatting includes labeling each trajectory ("Thinker #1", "Thinker #2", etc.), inserting separators, and embedding everything within a structured prompt template.

The formatting template (from Figure 7, Appendix C). The serialized cache is constructed using the following structure:

1. A preamble that tells the model its role: "You are a great reasoner."
2. A description of what follows: "Here is a problem, and multiple thinkers attempt to give their thought processes independently. Each thinker has written its own thought process towards the final answer."
3. The original problem, wrapped in delimiters: # ====== Problem ====== {problem} # ====== Problem End ======
4. The trajectory block, introduced by: # ====== Thinkers Thought Process ======
5. Each trajectory, labeled sequentially: # ----- Thinker #1 ----- {trajectory_1_text} # ----- Thinker #2 ----- {trajectory_2_text} ... up to $K$ thinkers.
6. Closing delimiter: # ====== Thinkers Thought Process End ======
7. The deliberation instruction (described in §3.4.3).

The formatting function C(x_c) for serializing the trajectories is given explicitly in Figure 7 as a Python code snippet:

response_prompt = ""
for ei, response in enumerate(parallel_reason_content_list):
    response_prompt += "# ----- Thinker #{} -----\n\n{}\n\n".format(ei + 1, response)
prompt = prompt.replace("{problem}", query).replace("{response_prompt}", response_prompt)

This concatenates each trajectory with its thinker label, separated by blank lines, into a flat string that replaces the {response_prompt} placeholder in the prompt template.

Why this form: The explicit labeling ("Thinker #1", "Thinker #2") is crucial—it provides the deliberation model with a clear way to reference and compare specific trajectories. Without labeled boundaries, the model would receive an undifferentiated wall of text and would struggle to attribute specific reasoning steps to specific trajectories. The numbering also enables the model to notice patterns: "Thinker #1 and Thinker #3 both use an algebraic approach and arrive at answer X, while Thinker #2 uses a geometric approach and arrives at answer Y." The structured delimiters (====== and -----) are chosen to be visually distinct from typical mathematical notation, reducing the risk that the model confuses delimiter tokens with problem content.

Shuffling to prevent positional bias. The paper explicitly states that "pruned trajectories are shuffled to prevent the model from developing a bias toward specific positions in the prompt." This is a subtle but important detail: LLMs are known to exhibit positional biases—they may pay more attention to content at the beginning or end of the prompt. If the trajectories were always presented in the order they were generated, the model might learn (or already exhibit) a preference for the first trajectory or the last trajectory, regardless of its actual quality. Shuffling breaks this spurious correlation.

Pruning for context length. The paper notes that "serializing all complete trajectories would exceed the model's maximum length limit." This is a practical constraint: each reasoning trajectory from a modern reasoning model can be thousands of tokens (including extensive chain-of-thought), and concatenating 8 or 16 such trajectories can easily exceed typical context windows (which may be 32K, 128K, or 1M tokens depending on the model). The paper states that trajectories are pruned but does not specify the exact pruning algorithm (e.g., truncation of thinking content, removal of low-information segments, or selection of a subset). This is a notable omission—the pruning strategy could significantly affect what information the deliberation model has access to, and the paper's silence on this point means the results may be sensitive to implementation details that are not fully specified.

What the deliberation model sees versus what the parallel models saw. An important asymmetry: the parallel reasoning models ($\pi_\theta$) each see only the original problem and their own generation so far. The deliberation model ($\pi_\phi$) sees the original problem PLUS all $K$ complete trajectories. This means the deliberation model has access to substantially more information than any individual parallel model. This asymmetry is the mechanism by which deliberation can outperform individual trajectories: it can compare approaches, spot errors that are obvious in hindsight but subtle in isolation, and synthesize partial insights from different trajectories.

3.4.3 The Sequential Deliberation Stage: Synthesis Through Meta-Reasoning

The sequential deliberation stage is the intellectual core of heavy thinking. It transforms a set of independent reasoning attempts into a single, improved answer through critical analysis, comparison, and synthesis. This is not simply selecting the best trajectory or voting—it is a meta-cognitive process where the model reasons about the reasoning of other instances of itself.

Formal specification. Given the serialized cache $x_c$, the deliberation model $\pi_\phi$ generates $K^{(1)}$ outputs (the paper uses $K^{(1)} = 4$ in the main experiments):

$T_{\pi_\phi}(x_c, K^{(1)})$

where $x_c$ is the serialized memory cache (containing the original problem and all $K$ trajectories) and $K^{(1)}$ is the number of independent deliberation outputs to generate. The paper uses multiple deliberation outputs ($K^{(1)} = 4$) rather than a single one, enabling further aggregation (e.g., majority voting across deliberations, or computing Heavy-Mean@4 and Heavy-Pass@4 metrics).

The deliberation prompt (from Figure 7, Appendix C). The prompt template instructs the deliberation model to perform a specific sequence of cognitive operations:

1. Read and understand the original problem (provided at the top of the cache).
2. Read all $K$ thinkers' thought processes (the labeled trajectories).
3. Summarize their thinking: "Summarize their thinking on the problem and try to summarize the thinking of these thinkers."
4. Analyze differences: "Analyze the differences in thinking between these thinkers and try to analyze which thought process is correct."
5. Apply critical judgment with a specific warning against naive consensus:

"It is generally believed that when most thinkers get the same answer, the answer may be correct. But you can't do it so superficially, because the correct answer may come from very few thinkers, or even no thinker gives the correct answer. For this reason, when you summarizing, you NEED adhere to the principles of professionalism and critical thinking, carefully identify these thought processes, and give a summary and final answer."

6. Re-derive if necessary:

"If you realize that none of these thinkers have answered correctly, you can even learn from the wrong experiences in the thought process of these thinkers and re-think the given problem to give the answer you think is most correct."

7. Produce a summary first, then the answer:

"Please DO NOT just solve the given problem independently like other thinkers, but summarize the thought process of all thinkers. In other words, you need to give the summary first, and then give the final answer, you can re-think this problem only if you realize that none of these thinkers have answered correctly."

8. Follow output format conventions: Mathematics answers in \boxed{}, code in markdown code blocks.

What this computes: This is a reasoning-about-reasoning process. The deliberation model does not just receive a problem and produce an answer—it receives a problem, $K$ complete solution attempts (with their reasoning and answers), and instructions to critically evaluate, compare, synthesize, and potentially re-derive. The output is a structured response containing both a meta-analysis (the summary of what the thinkers did, where they agreed/disagreed, what errors were made) and a final answer.

Why this form (the specific prompt design choices):

• The explicit warning against naive majority voting. The paper's empirical results show that majority voting (Vote@K) is strong but suboptimal—on difficult problems, the majority answer is often wrong, and the correct answer may come from a single trajectory. If the deliberation model simply counted votes, it would replicate Vote@K. The prompt explicitly instructs against this, pushing the model toward genuine analysis of reasoning quality rather than statistical aggregation. This is what enables Heavy-Mean@K to exceed Vote@K on challenging benchmarks.

• The permission to re-derive when all trajectories are wrong. This is the mechanism that enables Heavy-Pass@K to exceed Pass@K in some cases: if none of the $K$ trajectories contains the correct answer, the deliberation model is instructed to "learn from the wrong experiences" and produce its own solution. The model may notice that the trajectories all share a common error (e.g., a misapplied theorem, a sign error at a specific step) and correct it, producing a correct answer that was not present in any input trajectory. This is a form of error-mode detection—the model identifies why all attempts failed and generates a corrected solution.

• The requirement to produce a summary before the answer. This enforces that the model engage in explicit meta-reasoning rather than jumping directly to an answer. The summary acts as a "scratchpad" where the model can articulate its comparative analysis, making the subsequent answer generation more grounded. This is analogous to chain-of-thought prompting, but at the meta-level: the model thinks about the set of previous thoughts before producing its own synthesis.

• Format consistency instructions. By instructing the model to match the output format conventions (\boxed{} for math, code blocks for programming), the prompt ensures that the deliberation output can be parsed and evaluated using the same grading infrastructure as the parallel reasoning outputs.

What the deliberation model does in practice (from the qualitative analysis in the paper). The paper provides a qualitative observation (in the Introduction) that "models explicitly compare trajectory differences during deliberation, functioning as implicit verifiers." This means the deliberation model naturally engages in behaviors like:

• Identifying which trajectories agree on the final answer
• Tracing where trajectories diverge in their reasoning
• Spotting algebraic or logical errors in specific steps
• Noting when two trajectories arrive at the same answer through different methods (providing convergent evidence)
• When trajectories disagree, assessing which reasoning chain is more rigorous

This is a learned behavior—the model was not fine-tuned for this task—but emerges from the combination of the prompt structure and the model's pre-trained capabilities in reasoning and critique.

Why separate parallel reasoning and deliberation into two stages. A natural alternative would be to include multiple reasoning trajectories inline within a single generation (as in Group Think, Hsu et al., 2025). The paper's two-stage design has several practical advantages:

• True independence: Parallel trajectories are generated with completely independent sampling, with no opportunity for the model to "peek" at other trajectories and conform its reasoning. In inline approaches, later trajectories are conditioned on earlier ones (since they appear earlier in the token sequence), which can reduce diversity.
• Flexible model pairing: The reasoning model ($\pi_\theta$) and deliberation model ($\pi_\phi$) can be different models—e.g., using a small, fast model for parallel reasoning and a large, capable model for deliberation. This decoupling is central to the paper's analysis in Section 4.2 (cross-model pairing experiments).
• Computational efficiency: Parallel trajectories can be generated concurrently on multiple GPUs or API instances, reducing wall-clock time. In inline approaches, the trajectories must be generated sequentially.
• Memory cache reusability: The serialized cache can be stored, shuffled, and reused across different deliberation models or multiple iterations without regenerating the trajectories.

The grading question. How do we know the deliberation model is actually performing synthesis rather than just picking the best trajectory or outputting the most common answer? The paper's evidence is indirect but suggestive: the fact that Heavy-Pass@K can exceed Pass@K (Table 1) proves that the deliberation model sometimes produces correct answers that did not exist in any input trajectory. This cannot be explained by selection or voting—it requires genuine synthesis or re-derivation. The paper does not, however, provide a systematic analysis of how often this synthesis occurs versus how often deliberation simply selects from existing answers, which is a limitation of the qualitative analysis.

3.4.4 Iterative Deliberation: Recursive Refinement

The paper introduces an optional extension where the deliberation process is repeated multiple times, with each iteration's output fed back into the memory cache for the next iteration. This is motivated by analogy to human behavior: "in the real-world [humans] repeatedly refine the ideas that were previously considered."

Formal specification. For iteration $t \in \{2, ..., N\}$ (where the first iteration $t=1$ is the standard deliberation described above), the memory cache is modified by concatenating the previous iteration's deliberation output:

$x_c^{(t)} = T_{\pi_\phi}(x_c^{(t-1)}, K^{(t-1)}) \parallel x_c^{(t-1)}$

where:

• $x_c^{(t)}$ is the updated memory cache for iteration $t$
• $T_{\pi_\phi}(x_c^{(t-1)}, K^{(t-1)})$ is the deliberation model's output from the previous iteration (containing both summary and answer)
• $K^{(t-1)}$ is the number of generated summary contents at the previous deliberation phase
• $\parallel$ denotes string concatenation
• $N$ is the total number of iterations

What this computes: After the first deliberation, the system appends the deliberation output to the existing memory cache (which already contains the original problem and the $K$ parallel trajectories). The deliberation model then reads this augmented cache—which now includes its own previous analysis—and produces a new synthesis. This can be repeated for $N$ iterations.

Why this form: The intuition is that the first deliberation pass may miss some insights or make errors. By seeing its own previous analysis alongside the raw trajectories, the model can:

• Notice gaps or oversights in its previous synthesis
• Incorporate insights that it generated in the previous iteration but didn't fully develop
• Refine its answer based on further reflection

The concatenation order ($T_{\pi_\phi}(x_c^{(t-1)}) \parallel x_c^{(t-1)}$) puts the new deliberation output at the beginning, before the original cache. This means the model sees its own most recent thinking first, then the historical context. The paper does not discuss alternative ordering strategies, but this placement likely reflects the recency bias observed in LLMs—content appearing later in the prompt tends to have more influence on generation.

Experimental configuration for iterative deliberation. The paper's experiments in Section 4.3 fix the number of outputs at each stage: $K = K^{(1)} = ... = K^{(N)} = 8$ (8 parallel trajectories, 8 deliberation outputs per iteration). The total number of iterations $N$ is set to 4. This means the full iterative pipeline generates: 8 parallel trajectories + 8 deliberation outputs (iteration 1) + 8 deliberation outputs (iteration 2) + 8 deliberation outputs (iteration 3) + 8 deliberation outputs (iteration 4) = a total of $8 + 4 \times 8 = 40$ generations.

Observed behavior and the trade-off. The paper reports (Figure 4, Section 4.3) that Heavy-Mean@K (HM@K) consistently improves with more iterations, while Heavy-Pass@K (HP@K) degrades. Specifically:

"we observe a consistent upward trend in the HM@K metric as the number of iterations increases... However, this gain is accompanied by a significant degradation in the HP@K metric."

The paper's interpretation is that iterative processing introduces "cumulative noise or biases that constrain the model's refinement space." In operational terms: as the model re-reads its own previous analyses, it may become increasingly anchored to specific interpretations or answer choices, limiting its ability to consider radically different approaches. The mean quality of outputs improves (HM@K rises) because the model refines within the neighborhood of its initial analysis, but the best possible output from any single deliberation pass (captured by HP@K, which is an "at least one is correct" metric) declines because the diversity of the deliberation outputs collapses—the model keeps producing variations on the same theme rather than exploring genuinely new possibilities.

Why this matters for the overall framework. The iterative deliberation results reveal a fundamental tension in the heavy thinking paradigm: there is a trade-off between depth of refinement (more iterations, better average quality) and breadth of exploration (fewer iterations, higher chance of a breakthrough re-derivation). The paper does not propose a mechanism for adaptively deciding when to iterate versus when to stop, which represents a natural extension—similar to the "compute-optimal scaling" concept from the example paper analyzed earlier, where the allocation of test-time compute between search and revision is adapted based on estimated problem difficulty.

3.4.5 The Readable Skill: Packaging Heavy Thinking as a Transferable Capability

Section 2.4 introduces a distinctive contribution: distilling the entire heavy thinking workflow into a readable skill document—a structured natural-language specification that any sufficiently capable LLM orchestrator can read and execute autonomously, without requiring external pipeline code.

Motivation: from code to capability. The paper draws an explicit connection to modern agentic harness practices:

"modern agentic harnesses—such as Claude Code, CodeX, and Hermes—organize capabilities as skills: human-readable, model-interpretable documents that the orchestrator loads into its context window at inference time. A skill specifies when to activate, how to execute, and what to output, without requiring any code modification to the harness itself."

This reflects a shift in how capabilities are implemented in agentic systems. Rather than hard-coding orchestration logic in Python scripts that manage API calls and route outputs, these frameworks provide a skill interface where the LLM orchestrator itself reads a specification document and executes the prescribed protocol. The HEAVYSKILL document is a concrete instantiation of this pattern for heavy thinking.

The four components of the readable skill:

1. Activation Conditions: A declarative description of when heavy thinking should be triggered. The skill instructs the orchestrator to activate when facing tasks involving complex reasoning (mathematical, logical, algorithmic) and to remain dormant for simple factual queries, casual conversation, or straightforward code edits. The skill document explicitly lists:

   • Activate for: mathematical reasoning, complex logical deduction, code competition, tasks where correctness is critical and verifiable, problems where the model is uncertain about its initial approach
   • Do NOT activate for: simple factual questions, casual conversation, straightforward code edits, information retrieval tasks

   This conditional activation is important because heavy thinking is expensive—spawning $K$ parallel agents and performing deliberation multiplies the inference cost by approximately $K+1$ (plus any iterative overhead). Applying this cost to every query, including trivial ones, would be wasteful.

2. Parallel Reasoning Protocol: Instructions for the orchestrator to spawn $K$ independent reasoning agents in parallel, each solving the same problem from scratch "without access to other agents' outputs." The skill encourages diversity: "Use different reasoning approaches when possible (e.g., algebraic vs. geometric, brute force vs. elegant)." In the harness context, each agent corresponds to a subagent call—a native capability of modern orchestration frameworks. The recommended $K$ in harness mode is 3–5 (versus 8+ in the workflow mode), reflecting the higher per-agent overhead of orchestration frameworks compared to direct API calls.

3. Deliberation Prompt Template: The core of the skill is a carefully designed prompt for the sequential deliberation stage. This corresponds to the "General-Prompt" in the workflow implementation (Figure 7). The skill specifies that the deliberation model must:

   • Classify the query type to determine appropriate analysis depth
   • Critically evaluate each thinker's reasoning rather than naively following the majority
   • Re-derive the answer from scratch when all thinkers are judged to be incorrect
   • Maintain language and format consistency with the original query
   • Avoid "superficial concatenation of thinker outputs" and demand "genuine synthesis"

4. Output Constraints: The final response must contain only the answer—not the meta-analysis—and must follow format conventions of the target domain. This is a pragmatic choice for harness integration: the orchestrator typically expects clean outputs that can be passed to downstream tools or presented to the user, not interleaved meta-reasoning.

The key distinction from the workflow mode. The paper explicitly distinguishes the workflow mode (an external Python pipeline orchestrating API calls, managing the memory cache, and routing outputs) from the skill mode (the LLM orchestrator itself reads the skill document and autonomously executes the protocol). The difference is the locus of control:

"In the skill mode, the LLM orchestrator itself reads the skill document and autonomously executes the prescribed protocol—spawning parallel agents, collecting their outputs into its context window as a serialized memory cache, and performing deliberation in a subsequent generation step."

This self-orchestration is possible because frontier LLMs have strong in-context learning and instruction-following capabilities—they can faithfully follow multi-step procedural instructions embedded in their prompt without external code managing the workflow.

Portability as evidence for the "inner skill" thesis. The paper emphasizes that the skill document "can be injected into any harness that supports skill loading and subagent spawning" and reports that the same HEAVYSKILL document functions correctly under both Claude Code and custom orchestration harnesses without modification:

"This portability aligns with our central thesis: heavy thinking is not an artifact of a particular system design but an inner skill that can be activated across diverse orchestration environments."

This is a specific empirical claim: if heavy thinking were an artifact of a particular orchestration framework's implementation details, it would not transfer across different frameworks. The fact that it does transfer—documented through working across at least two different harnesses—supports the paper's framing of heavy thinking as a capability pattern rather than a system artifact.

Implications for internalization through training. The readable skill serves as an intermediate step in the paper's broader thesis. The full arc is:

1. External orchestration: complex multi-agent frameworks with opaque performance drivers
2. Decomposed workflow: the two-stage pipeline identified as the minimal effective mechanism
3. Readable skill: the pattern distilled into a portable, natural-language specification
4. RLVR training: the pattern internalized into model parameters through reinforcement learning

The readable skill occupies step 3 in this progression. By demonstrating that the pattern can be expressed as a compact, transferable specification, the paper provides evidence that it is specifiable—and therefore trainable. If the pattern could only be implemented through complex, framework-specific code with many brittle dependencies, it would be unclear whether it could ever be internalized through training. A clean, self-contained specification suggests the opposite.

3.4.6 Consolidated Configuration and Hyperparameters

For reference, here is a consolidated listing of all configuration choices described in the methodology, with the paper's rationale (where provided) and implications:

Parallel reasoning stage:

• $K$ (number of parallel trajectories): 8 or 16 in workflow mode; 3–5 recommended in harness (skill) mode
• Sampling parameters: temperature = 1.0, top_p = 0.95, top_k = 10
• Rationale: High diversity settings to ensure trajectories explore different solution strategies, providing rich material for deliberation to synthesize
• Model: Default is $\pi_\theta = \pi_\phi$ (same model for both stages), though Section 4.2 experiments with different model pairings

Sequential deliberation stage:

• $K^{(1)}$ (number of deliberation outputs): 4 in main experiments; 8 in iterative deliberation experiments (Section 4.3)
• Rationale for 4: Balances statistical robustness (multiple deliberation outputs enable Heavy-Mean@4 and Heavy-Pass@4 metrics) with inference cost
• The deliberation model uses the same sampling parameters as parallel reasoning (temperature = 1.0, top_p = 0.95, top_k = 10)
• Rationale: Diversity in deliberation outputs is also valuable—it allows the system to compute Heavy-Mean@4 across multiple synthesis attempts

Iterative deliberation (optional):

• $N$ (total iterations): 4 in experiments (Section 4.3)
• $K^{(t)}$ (outputs per iteration): fixed at 8 for all iterations in iterative experiments
• Total generations: $K + \sum_{t=1}^{N} K^{(t)} = 8 + 4 \times 8 = 40$ for the iterative configuration

Memory cache:

• Shuffling: Trajectories are shuffled before presentation to prevent positional bias
• Pruning: Trajectories are pruned if the serialized cache would exceed the model's maximum context length (specific pruning algorithm not detailed)
• Formatting: Each trajectory labeled as "Thinker #N" with clear delimiters (Figure 7)

Readable skill (harness mode):

• Activation conditions: Complex reasoning, mathematics, code competition, verifiable correctness tasks
• Non-activation: Simple factual queries, casual conversation, straightforward edits, retrieval
• Format compliance: \boxed{} for mathematics, code blocks for programming
• Portability: Verified working under Claude Code and custom harnesses

Metric definitions (for evaluation):

• Mean@K (M@K): Average accuracy of the $K$ parallel trajectories
• Pass@K (P@K): Fraction of queries where at least one of $K$ trajectories is correct
• Vote@K (V@K): Accuracy of majority voting across $K$ trajectories (baseline Best-of-N)
• Heavy-Mean@K (HM@K): Average accuracy of the $K^{(1)}$ deliberation outputs
• Heavy-Pass@K (HP@K): Fraction of queries where at least one deliberation output is correct

What is notably absent from the specification:

The paper does not specify several details that would be needed for exact reproduction:

• The exact pruning algorithm for trajectories when the serialized cache exceeds context length
• The exact prompt used for the parallel reasoning stage (the skill file provides the parallel agent prompt template, but the main workflow experiments may use different prompting)
• Any handling of cases where the deliberation model produces unparseable outputs or fails to follow the required output format
• The specific shuffling algorithm (e.g., random permutation? seeded?)
• Details of how tool-interleaved heavy thinking (Section 4.4) modifies the prompt template to include tool execution feedback

These omissions are common in empirical systems papers where the contribution is the framework and findings rather than a single, fully-specified algorithm. However, they represent implementation details that could affect reproducibility and should be addressed in any released code or more detailed documentation.

4. Key Insights and Innovations

Innovation 1: Heavy Thinking as a Minimal Cognitive Unit Isolated from Orchestration Infrastructure

The dominant paradigm in LLM-based agent systems over the past several years has been the orchestration framework: a complex, engineered system that coordinates multiple specialized agents, each with its own memory, skills, and tool access, through a central orchestrator model. Frameworks like Claude Code, CodeX, OpenClaw, and Hermes have achieved remarkable success on complex reasoning tasks, but they do so through architectures that bundle together role decomposition, inter-agent communication protocols, skill libraries, memory retrieval, tool routing, and iterative refinement loops into intricate system-level artifacts. The field has accepted that these frameworks work, but it has lacked an analytical decomposition of which mechanisms are essential and which are incidental.

The paper's most fundamental conceptual contribution is the claim that these elaborate orchestration architectures can be reduced to a single minimal cognitive operation: parallel reasoning followed by sequential deliberation. The paper abstracts away the multi-agent framework's role assignments, communication protocols, skill libraries, and memory management infrastructure, and demonstrates that the core pattern—spawn independent solvers, collect their outputs, synthesize—can be isolated, studied independently, and executed without any orchestration scaffolding.

What makes this a genuine intellectual innovation rather than an obvious simplification is that the paper provides empirical evidence that this minimal unit captures the performance-driving mechanism. The heavy thinking pattern, executed as a simple two-stage prompting strategy with no multi-agent architecture, no tool routing, and no specialized memory beyond a serialized text cache, achieves results that consistently outperform traditional Best-of-N strategies (Table 1) and, in frontier models, approach the theoretical Pass@K upper bound—the ceiling of what the model could achieve if it always selected its best individual trajectory. If the multi-agent orchestration contributed substantial additional value beyond the parallel-reasoning-then-deliberation pattern, we would expect the heavy thinking pipeline to underperform full orchestration frameworks. The paper does not provide a direct head-to-head comparison with full orchestration systems (a limitation), but the absolute performance levels achieved—near-perfect scores on AIME25 and HMMT25-Feb for frontier models like Kimi K2 Thinking and GPT-5-Thinking—suggest that the minimal pattern captures a large fraction of what orchestration frameworks deliver.

This is a fundamental reframing of the agent systems research agenda. Prior work on multi-agent orchestration implicitly assumed that the complexity of the system architecture was necessary for the performance gains—that role specialization, inter-agent debate, and structured communication protocols contributed nontrivially to solution quality. By demonstrating that a simple, architecture-agnostic two-stage pipeline achieves comparable or superior results, the paper shifts the burden of proof: future work must demonstrate that additional orchestration complexity provides gains beyond what heavy thinking alone can achieve, rather than assuming the complexity is justified.

The distillation into a readable skill document (Section 2.4, Figures 8-10) operationalizes this reframing. The fact that the same natural-language specification works across different orchestration harnesses (Claude Code and custom frameworks, as verified by the authors) provides a clean empirical test of the "minimal unit" hypothesis: if heavy thinking were an artifact of a particular system's implementation, it would not transfer; the fact that it does transfer supports the claim that the pattern is a cognitive capability, not an engineering artifact.

Innovation 2: Deliberation as Synthesis, Not Selection—Exceeding the Pass@K Upper Bound

The standard approach to extracting value from multiple parallel LLM generations is selection: generate N candidates, then pick the best one using some scoring mechanism. Majority voting (Vote@K) selects the most common answer; Best-of-N with a learned verifier selects the highest-scoring candidate; Pass@K measures the theoretical ceiling of what selection could achieve—if an oracle always picked the correct trajectory when one exists, performance would equal Pass@K. The implicit assumption in this paradigm is that parallel generation provides raw material, and the task is to identify the best existing output.

The paper's most striking empirical finding challenges this assumption. The sequential deliberation stage does not merely select from existing trajectories—it synthesizes new insights by comparing and contrasting different reasoning paths. The evidence for this claim comes from a specific result that appears across multiple models and benchmarks: Heavy-Pass@K can exceed Pass@K (Table 1, Table 2). For instance, on HMMT25-Feb with GPT-5-Thinking at K=16, Pass@K is 96.7 while Heavy-Pass@4 reaches 96.7—tying the upper bound of what any individual trajectory contains. More dramatically, on the IMO Answer Bench (Table 2), GLM 4.6 achieves an HP@4 of 86.0 versus a P@K of only 75.1—a 10.9 percentage point improvement that represents correct answers the model never generated in any of its parallel reasoning attempts.

This finding has a fundamental implication that the paper states explicitly: "the deliberation process does not merely select from existing answers but can synthesize cross-trajectory insights to generate correct solutions that were not present in any single raw reasoning path." This is what the paper means by "implicit verifier"—the deliberation model reads the errors made across multiple trajectories, identifies the common failure modes, and reasons its way to a correct answer that none of the inputs contained. The prompt's explicit instruction—"If you realize that none of these thinkers have answered correctly, you can even learn from the wrong experiences... and re-think the given problem" (Figure 7)—enables this behavior, but it is the model's underlying capability that executes it.

This is a fundamental conceptual advance, not an incremental improvement. Prior work on test-time compute scaling (Brown et al., 2024; Lightman et al., 2024; the compute-optimal scaling paper from the reference example) treated the problem as one of search: how do we efficiently explore the model's output distribution to find the best existing solution? The heavy thinking framework reframes the problem as one of synthesis: the combination of multiple reasoning attempts can produce insights that exist in none of them individually. This is analogous to the difference between finding the best individual sentence in a document and reading the entire document to produce a new, more accurate summary—the whole contains information not present in any part.

The practical consequence is that the theoretical ceiling for test-time compute scaling is higher than previously understood. Under the selection paradigm, the ceiling is Pass@K—you cannot exceed the best individual output. Under the synthesis paradigm, the ceiling is determined by the deliberation model's ability to extract cross-trajectory insights, which may exceed any individual trajectory's quality. This provides a stronger theoretical motivation for investing in test-time compute: it is not just about finding needles in haystacks, but about creating new needles from the hay.

A critical nuance: the paper does not claim that deliberation always exceeds Pass@K. In many configurations, Heavy-Mean@K falls below Pass@K (the gap between HM@4 and P@K in Table 1 is substantial for smaller models). The claim is that exceeding Pass@K is possible and that it occurs with sufficient frequency (in "nearly half of our experimental trials" with frontier models, per Section 3.2) to establish deliberation as a qualitatively different mechanism from selection. The fact that the effect is most pronounced in frontier models suggests that synthesis capability scales with base model strength—a finding with immediate implications for where to invest test-time compute.

Innovation 3: Decomposing Test-Time Compute into Width (Parallel Reasoning) and Depth (Deliberation) as Independent Scaling Axes

The paper identifies and empirically characterizes two distinct, complementary axes of test-time compute scaling that operate at different levels of the reasoning process. This decomposition is implicit in the heavy thinking pipeline but is made explicit through the paper's ablation experiments and cross-model pairing analysis.

Width corresponds to the number of parallel reasoning trajectories K—how many independent solution attempts are generated. Increasing K costs linear compute (more API calls or GPU time) and provides the deliberation model with more raw material to analyze. The paper's Appendix A (Figure 5) shows that increasing K from 8 to 64 consistently improves performance across all trajectory selection strategies, confirming that width scaling is a reliable lever for improving heavy thinking outcomes. The optimal strategy for selecting which of the many generated trajectories to include in the memory cache is Max-Answer-Num (selecting trajectories with the most common answers, i.e., majority-vote pre-filtering), which significantly outperforms random selection, maximum-diversity selection, and maximum-length selection.

Depth corresponds to the number of deliberation iterations N—how many times the deliberation model re-reads its own previous analyses and produces a refined synthesis. The paper's Section 4.3 (Figure 4) reveals a fascinating and non-obvious dynamic: increasing depth consistently improves Heavy-Mean@K (the average quality of deliberation outputs improves as the model iterates) but degrades Heavy-Pass@K (the best individual deliberation output gets worse as the model becomes increasingly anchored to its initial analysis). This is a novel empirical finding that has no analog in prior test-time compute scaling literature: the average case and the best case respond in opposite directions to iterative refinement, creating a trade-off that must be actively managed.

The paper's interpretation is that iterative deliberation introduces "cumulative noise or biases that constrain the model's refinement space" (Section 4.3). In operational terms: the first deliberation pass considers the raw trajectories with fresh eyes and can discover novel syntheses; subsequent passes are increasingly conditioned on the model's own previous analysis, which anchors the reasoning and reduces the diversity of possible outputs. The mean improves because the model is refining within a promising region; the best-case degrades because the model has lost the ability to make the kind of discontinuous jump that produces a novel correct answer from all-wrong inputs.

This decomposition is significant because it provides a framework for understanding when and why different test-time compute strategies work. Width scaling (more parallel trajectories) is primarily about exploration—it increases the diversity of raw material available for synthesis. Depth scaling (more iterations) is primarily about exploitation—it refines within a discovered region of solution space. The fact that depth eventually harms the best-case outcome is an empirical manifestation of the classic exploration-exploitation trade-off, but instantiated in a novel context (LLM meta-reasoning) with a novel mechanism (progressive anchoring to one's own analysis). This finding has immediate practical implications: for problems where the model is likely to have generated at least one correct trajectory (high Pass@K), depth scaling may be beneficial; for problems where all trajectories are wrong and synthesis is required, limiting depth may preserve the deliberation model's ability to make novel discoveries.

The cross-model pairing experiments in Section 4.2 provide additional evidence that width and depth are independent, complementary axes. When the paper fixes the parallel reasoning model as R1-Distill-Qwen-7B and varies the deliberation model (R1-Distill-Qwen-7B, R1-Distill-Qwen3-8B, Qwen2.5-32B-Instruct), all pairings outperform the M@K baseline (Figure 3). Strikingly, Qwen2.5-32B-Instruct—a model that independently achieves only 12.8% on AIME25—performs competently as a deliberation model, suggesting that deliberation relies more on "comprehensive analysis, synthesis, and summarization" capabilities than on peak reasoning power. This decoupling has practical significance: the two stages can be optimized independently, with different models potentially specialized for the different cognitive demands of generation versus deliberation.

This is a fundamental insight that reframes how the field should think about allocating test-time compute budgets. Prior work on test-time scaling (the compute-optimal scaling paper from the reference example; Brown et al., 2024) optimized over different strategies (beam search vs. best-of-N, revisions vs. parallel sampling) but did not identify width and depth as orthogonal dimensions with qualitatively different scaling behaviors. The paper provides the first empirical characterization of how these two dimensions interact, establishing a conceptual vocabulary—width, depth, exploration, exploitation—that future work can use to design and analyze test-time compute strategies more systematically.

Innovation 4: Heavy Thinking as a Learnable Inner Skill—The Internalization Thesis and Initial RLVR Evidence

The paper's most forward-looking contribution is the thesis that heavy thinking is not merely an inference-time strategy to be executed by external orchestration code, but an inner skill that can be internalized within model parameters through reinforcement learning. This claim transforms heavy thinking from a deployment technique (something you do with a model) into a training objective (something the model learns to do).

The paper provides two forms of evidence for the internalization thesis. The first is the readable skill document (Section 2.4, Appendix C Figures 8-10), which demonstrates that the heavy thinking pattern is sufficiently well-specified that it can be expressed as a compact, portable natural-language specification rather than as fragile orchestration code. The paper explicitly frames this as an intermediate step: if the pattern can be specified in natural language with enough precision that a frontier LLM can execute it by reading the specification, then the pattern is specifiable—and therefore potentially learnable. This is a conceptual argument, not an empirical result, but it draws on the well-established finding that LLMs can learn from natural-language instructions.

The second, more concrete form of evidence comes from the RLVR experiments in Appendix B (Figure 6). The paper applies reinforcement learning from verifiable rewards to heavy thinking trajectories, using queries where the parallel reasoning pass rate is in the range [0, 0.625] (problems of moderate difficulty where heavy thinking has substantial room for improvement). During the initial training phase (first 100 steps), the model exhibits a consistent upward trend on both training and test sets, with the HM@4 metric improving by approximately 10%. This is a preliminary but positive signal: it suggests that the heavy thinking pattern can be optimized through standard RLVR pipelines (specifically, using the VeRL framework with GSPO as the RL algorithm).

However, the paper documents a critical instability: for the K=16 configuration (16 parallel trajectories in the serialized cache), the model experiences "significant entropy collapse after 100 steps," while the K=8 configuration remains stable. The paper attributes this to maximum sequence length limitations of the R1-Distill-Qwen-7B model, which "may lead to truncated or suboptimal training signals when handling longer serialized contexts." This is an important negative result that constrains the internalization thesis: training models to internalize heavy thinking requires handling very long context sequences (the serialized cache with 16 trajectories can approach or exceed standard context windows), and naively scaling up the number of parallel trajectories during RL training can cause training instability.

What makes this a genuine innovation is the conceptual arc it establishes: agentic orchestration → heavy thinking as the core mechanism → readable skill as the portable specification → RLVR as the path toward internalized capability. This arc provides a coherent research program that bridges the currently disparate fields of agent systems design, test-time compute scaling, and post-training optimization. The practical implication is clear: rather than investing indefinitely in building more elaborate orchestration frameworks with more agents, more communication protocols, and more hand-crafted heuristics, the field should invest in training models to internalize the core cognitive operation—parallel reasoning followed by deliberation—as a native capability. The paper's initial RLVR results are not sufficient to claim that internalization has been achieved (the 10% improvement is modest, the entropy collapse problem is unresolved, and the experiments are on a single 7B model), but they establish proof of concept and identify the key challenge (context length and training stability) that must be solved to realize the full vision.

This is a fundamental conceptual shift, not an incremental improvement over existing RLVR approaches (Yu et al., 2025; Yue et al., 2025; Liu et al., 2025). Prior RLVR work has focused on optimizing single-trajectory reasoning quality—teaching the model to produce better chain-of-thought, to self-correct, to verify its own steps. The heavy thinking RLVR paradigm expands the training objective: the model learns to simultaneously generate diverse reasoning paths (width) and synthesize across them (depth), internalizing the two-stage pipeline into a single model's parameters rather than executing it as an external protocol. If successful, this could produce models that naturally engage in parallel exploration and critical synthesis without any external orchestration—a qualitatively different kind of reasoning capability than what current post-trained models exhibit.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The paper evaluates on two broad categories: STEM tasks comprising AIME25, BeyondAIME, HMMT25-Feb, and GPQA-Diamond; and general reasoning tasks comprising LiveCodeBench (24.08–25.05), Arena-Hard, IFEval, and IMO (Answer Bench). No explicit dataset sizes are reported in the main text—AIME25 typically contains 30 problems, HMMT25-Feb likely a similar contest scale, GPQA-Diamond 198 problems, and LiveCodeBench several hundred, but exact per-benchmark test counts are not stated. The STEM benchmarks are chosen for their verifiable numerical answers and high reasoning difficulty; the general benchmarks span coding (LiveCodeBench), instruction-following (IFEval), open-ended preference (Arena-Hard), and mathematical answer extraction (IMO Answer Bench).

• Base model(s). The paper evaluates a broad spectrum spanning three categories: leading close-weight models (GPT-5-Thinking, Claude 4.5 Thinking, Gemini 3 Pro Preview); open-weight reasoning models at multiple scales (R1-Distill-Qwen-7B, R1-Distill-Qwen-32B, R1-Distill-Qwen3-8B, Qwen3-8B, Qwen3-32B, DeepSeek R1-0528, GPT-OSS-20B, Kimi K2 Thinking, GLM 4.6, DeepSeek V3.2 Thinking). This range—from 7B distilled student models to frontier-scale proprietary systems—is deliberate: the paper aims to characterize heavy thinking behavior across the full capability spectrum, establishing whether the observed patterns are universal or scale-dependent.

• Metrics. Five metrics are defined for evaluation. Mean@K (M@K) is the average accuracy of the K parallel reasoning trajectories—the fraction of individual trajectories that are correct. Pass@K (P@K) is the proportion of queries where at least one of the K trajectories is correct, measuring the theoretical upper bound of selection-based strategies. Vote@K (V@K) is the accuracy of majority voting across K trajectories, equivalent to Best-of-N with majority selection. Heavy-Mean@K (HM@K) is the average accuracy of the K⁽¹⁾ deliberation outputs (K⁽¹⁾ = 4 in main experiments). Heavy-Pass@K (HP@K) is the proportion of queries where at least one deliberation output is correct. For STEM tasks, correctness is determined by exact answer matching using standard grading functions (e.g., the Lightman et al. grading function for MATH-format problems, per Appendix G reference in the prior section context); the specific grading protocol for each benchmark is not detailed.

• Baselines. The primary baselines are the standard test-time scaling metrics computed from the parallel reasoning stage itself: Mean@K (average single-trajectory performance), Pass@K (oracle selection upper bound), and Vote@K (majority voting, representing the traditional Best-of-N strategy). Majority voting is the most direct comparison for Heavy-Mean@K because both aggregate K parallel trajectories into a single answer—voting does it statistically, deliberation does it through meta-reasoning. There are no external baseline systems (e.g., prior parallel reasoning frameworks like Group Think or Tree of Thoughts) directly compared; the paper evaluates heavy thinking against the internal baselines derived from its own parallel reasoning stage.

• Generation budget / compute accounting. The generation budget is measured in trajectory counts. The parallel reasoning stage consumes K generations. The sequential deliberation stage consumes K⁽¹⁾ generations (set to 4 in main experiments, 8 in iterative experiments). Total generations for a non-iterative run are K + K⁽¹⁾. For iterative deliberation with N iterations and K = K⁽¹⁾ = ... = K⁽ᴺ⁾ = 8 and N = 4, total generations are 8 + 4 × 8 = 40. The paper does not account for the cost of the memory cache construction (shuffling, pruning) or for the differing per-token costs of parallel reasoning trajectories versus deliberation trajectories (which may have different lengths). When comparing to Vote@K baselines, the comparison is at equal K (same number of parallel trajectories); the additional deliberation cost of 4–8 generations is an extra inference expense that Vote@K does not incur, making the comparison somewhat favorable to the baselines (i.e., heavy thinking pays more compute for its accuracy gains).

• Cross-validation / statistical protocol. The paper does not describe a cross-validation or train/test splitting protocol for strategy selection. For the RLVR experiments (Appendix B), training and test curves are shown in Figure 6, but no cross-validation folds or error bars are reported. The main experiments in Tables 1–3 report point estimates without confidence intervals. For the cross-model pairing experiments (Section 4.2), the parallel reasoning model is fixed and the deliberation model varied—this is a single experimental configuration per pairing without repeated trials reported. For the iterative deliberation experiments (Section 4.3), the reported values appear to be single-run results without variance estimates. The paper's empirical claims are therefore based on point estimates without statistical significance testing, which limits the strength of conclusions about small performance differences.

Main Quantitative Results

STEM Task Results: Heavy Thinking Consistently Outperforms Best-of-N

The headline result for STEM tasks appears in Table 1, which reports M@K, P@K, V@K, HM@4, and HP@4 across 17 model configurations on four benchmarks. The central finding is that HM@4 consistently exceeds M@K across all models and all STEM benchmarks, with the gains being largest on the hardest benchmarks (BeyondAIME, HMMT25-Feb) and for mid-capability models. For leading close-weight frontier models, performance approaches saturation—GPT-5-Thinking achieves HM@4 of 100 on AIME25 at K=16, Kimi K2 Thinking reaches 100 on AIME25 at K=8, and Gemini 3 Pro Preview reaches 100 on HMMT25-Feb at K=8—making further differentiation difficult.

Heavy thinking versus majority voting (the Best-of-N baseline). A more stringent comparison is HM@4 versus V@K—majority voting across the same K parallel trajectories. On AIME25 with R1-Distill-Qwen-7B at K=16, HM@4 achieves 56.7 versus V@K of 60.0—a slight underperformance. However, on harder benchmarks, the advantage reverses: on BeyondAIME with the same model at K=16, HM@4 achieves 35.3 versus V@K of 36.0 (roughly tied); on HMMT25-Feb, HM@4 is 31.7 versus 40.0 (underperformance); on GPQA-Diamond, HM@4 is 51.8 versus 51.1 (slight advantage). For R1-Distill-Qwen-32B on HMMT25-Feb at K=16, HM@4 achieves 45.8 versus V@K of 43.3—a clear advantage. For Qwen3-8B on GPQA-Diamond at K=8, HM@4 is 63.3 versus V@K of 62.1—marginal. The pattern is nuanced: on benchmarks where the model is near saturation (AIME25 for strong models), majority voting and heavy thinking converge; on harder benchmarks where the model has substantial room for improvement, heavy thinking's advantage becomes pronounced. The paper acknowledges this as a "ceiling effect" in Section 3.2: on AIME25, models like DeepSeek R1-0528 (90.0 V@K, 93.3 HM@4) and GLM 4.6 (96.7 V@K, 96.7 HM@4) have accuracy high enough that differentiation is limited.

Heavy-Pass@K exceeding Pass@K—evidence of synthesis. The most striking result in Table 1 is the relationship between HP@4 and P@K. For smaller models, HP@4 typically falls below P@K: R1-Distill-Qwen-7B on AIME25 at K=16 shows P@K = 66.7, HP@4 = 60.0. But for frontier models, HP@4 frequently approaches or matches P@K: GPT-5-Thinking on AIME25 at K=8 shows P@K = 100, HP@4 = 96.7; on HMMT25-Feb at K=8, P@K = 96.7, HP@4 = 96.7. Most notably, HP@4 exceeds P@K in several instances: DeepSeek V3.2 Thinking on AIME25 at K=8 shows P@K = 100, HP@4 = 96.7 (below), but at K=16, P@K = 100, HP@4 = 100 (ties). On the IMO Answer Bench in Table 2, GLM 4.6 achieves HP@4 = 86.0 versus P@K = 75.1—a 10.9 percentage point improvement that represents synthesis of correct answers not present in any parallel trajectory. Kimi K2 Thinking on this benchmark shows HP@4 = 88.0 versus P@K = 85.3—a smaller but positive gap. The paper states (Section 3.2) that "the potential of the heavy thinking (HP@4) exceeds the raw thinking potential (P@K) in nearly half of our experimental trials" for frontier models.

Scaling with K. Comparing K=8 to K=16 within the same model-benchmark pairs (Table 1): for GPT-5-Thinking on AIME25, HM@4 increases from 96.7 to 99.2; on BeyondAIME, from 79.5 to 82.5. For R1-Distill-Qwen-7B on AIME25, HM@4 increases from 50.0 to 56.7; on HMMT25-Feb, from 32.5 to 31.7 (roughly flat). The gains from doubling K are generally positive but modest, with diminishing returns on harder benchmarks for weaker models.

The performance hierarchy. The paper claims a consistent ordering: "Heavy-Pass@k ≥ Heavy-Mean@K ≥ Vote@K ≥ Mean@k" (Introduction). The data in Table 1 partially supports this but with important exceptions. The ordering HP@4 ≥ HM@4 holds universally (by definition: average cannot exceed maximum). HM@4 ≥ V@K holds on harder benchmarks (BeyondAIME, HMMT25-Feb, GPQA-Diamond) but fails on AIME25 for several models (R1-Distill-Qwen-7B at K=16: HM@4 = 56.7, V@K = 60.0; R1-Distill-Qwen-32B at K=16: HM@4 = 68.3, V@K = 66.7—mixed). V@K ≥ M@K holds universally except for models with very low M@K (where vote accuracy can be lower than mean if correct answers are rare and dispersed). The paper's hierarchical claim is therefore approximately true for harder benchmarks but does not hold universally on AIME25, where majority voting on raw trajectories can match or exceed heavy thinking for some model configurations.

General Reasoning Task Results: Task-Dependent Efficacy

Table 2 reports results on LiveCodeBench, Arena-Hard, IFEval, and IMO Answer Bench for five models. The pattern is domain-dependent: on tasks with objective, verifiable correctness (LiveCodeBench, IFEval), heavy thinking provides substantial gains; on subjective preference tasks (Arena-Hard), gains are marginal or negative.

LiveCodeBench. For GPT-OSS-20B, HM@4 (69.2) underperforms M@K (69.7)—a rare case where heavy thinking is slightly worse than the mean trajectory. However, HP@4 (85.5) substantially exceeds both, indicating that the deliberation model sometimes produces correct solutions when averaging across its outputs captures a wider range. For Kimi K2 Thinking, HM@4 (83.7) exceeds M@K (81.2) but HP@4 (80.4) is below P@K (91.0)—the deliberation model's best outputs underperform the best available parallel trajectory on this benchmark.

IFEval. The most dramatic improvement appears here: R1-Distill-Qwen3-8B achieves HP@4 = 86.5 versus P@K = 35.7—a 50.8 percentage point improvement. GPT-OSS-20B achieves HP@4 = 97.6 versus P@K = 90.8. These are the largest absolute gains reported anywhere in the paper and suggest that instruction-following, as evaluated by IFEval, is a task where deliberation across multiple attempts provides uniquely strong benefits—likely because the deliberation model can identify which formatting or constraint requirements are commonly missed across trajectories and ensure the final output satisfies them.

Arena-Hard. HM@4 and HP@4 are essentially flat or slightly below M@K for all models. Kimi K2 Thinking: M@K = 83.5, HM@4 = 83.1; GPT-OSS-20B: M@K = 25.4, HM@4 = 25.0. The paper attributes this to the "preference-oriented" nature of Arena-Hard, where the correctness signal is subjective and stylistic factors matter more than logical correctness.

IMO Answer Bench. This benchmark shows the strongest evidence for synthesis exceeding raw capability: GLM 4.6 achieves HP@4 = 86.0 versus P@K = 75.1 (+10.9); Kimi K2 Thinking achieves HP@4 = 88.0 versus P@K = 85.3 (+2.7); GPT-OSS-20B achieves HP@4 = 84.5 versus P@K = 81.5 (+3.0). Across all five models, HP@4 exceeds P@K for at least four of them, confirming that the deliberation process on mathematical reasoning tasks can reliably produce correct answers not present in the input trajectories.

Tool-Interleaved Heavy Thinking: External Feedback Enhances Gains

Table 3 reports results on AIME25 and HMMT25 with tool-interleaved reasoning, where the parallel reasoning stage includes Python interpreter calls with execution feedback. All experiments use K=8 with V@4 and HM@4 comparison.

On AIME25, GPT-OSS-20B achieves HM@4 = 90.0 versus V@4 = 83.3—a substantial 6.7 percentage point improvement. Qwen3-8B achieves HM@4 = 76.7 versus V@4 = 68.3 (+8.4). On HMMT25, the gains are larger: GPT-OSS-20B achieves HM@4 = 85.7 versus V@4 = 73.3 (+12.4); Qwen3-8B achieves HM@4 = 69.3 versus V@4 = 54.1 (+15.2). The interpretation is that the deliberation model leverages execution feedback signals (correct vs. incorrect code execution results embedded in the parallel trajectories) to more accurately assess which reasoning paths are valid and to identify common errors.

Notably, the M@K baseline for tool-interleaved reasoning is substantially lower than the HM@4 and V@4 metrics (e.g., GPT-OSS-20B on AIME25: M@K = 69.8, V@4 = 83.3, HM@4 = 90.0), consistent with the fact that individual trajectories often contain execution errors that get filtered out in aggregation but are averaged into the mean.

Difficulty-Dependent Analysis: Heavy Thinking Helps Most at Moderate Difficulty

Figure 2 provides a distributional analysis of heavy thinking's corrective capability across different parallel reasoning pass rates. Using R1-Distill-Qwen-7B on a 10K-query dataset drawn from Skywork OR1, DAPO, and DeepScaler (combined open-source data), the authors categorize queries by their parallel pass rate (fraction of K=16 trajectories that are correct, binned to {0.125, 0.375, 0.625, 0.875}) and measure the heavy pass rate after deliberation (K⁽¹⁾=16).

The key findings: 1) For queries with parallel pass rate below 0.5: Heavy thinking demonstrates substantial corrective potential. Although approximately 1,400 queries remain unresolved, over 500 are successfully rectified through deliberation. This means that on problems where fewer than half of the parallel trajectories are correct—and where majority voting would almost certainly fail—heavy thinking recovers the correct answer for a meaningful fraction. 2) For queries with parallel pass rate above 0.5: Heavy thinking maintains accuracy exceeding 98%, with only approximately 30 queries experiencing performance degradation. These are problems where the model already has high success probability, and deliberation rarely harms performance.

This analysis provides the paper's only systematic characterization of when heavy thinking works and when it doesn't: it works best as a corrective mechanism on moderately difficult problems (parallel pass rate 0.125–0.5) and serves as a reliable aggregator on easy problems (parallel pass rate >0.5). On very hard problems (parallel pass rate near 0), the figure implies that heavy thinking provides limited benefit—most queries remain unresolved—which is consistent with the intuition that deliberation cannot synthesize a correct answer from entirely incorrect raw material unless it can identify the common error mode and correct it.

Cross-Model Pairing: Deliberation Separable from Generation

Figure 3 reports results where the parallel reasoning model is fixed as R1-Distill-Qwen-7B and the deliberation model is varied among R1-Distill-Qwen-7B, R1-Distill-Qwen3-8B, and Qwen2.5-32B-Instruct. Benchmarks are AIME25 and HMMT25-Feb, with K=8 and K=16.

The consistent finding is that HM@K exceeds M@K for all deliberation model choices on both benchmarks. For AIME25 at K=16, the baseline M@K is approximately 43.5% (the fixed R1-Distill-Qwen-7B generation model's mean accuracy); HM@K ranges from 55.8% (R1-Distill-Qwen-7B deliberating on its own outputs) to 62.5% (R1-Distill-Qwen3-8B deliberating) to 53.3% (Qwen2.5-32B-Instruct deliberating). All are substantially above the baseline. For HMMT25-Feb at K=16, M@K is approximately 27.1%; HM@K ranges from 28.3% to 34.2% depending on deliberation model.

The counterintuitive finding is that Qwen2.5-32B-Instruct, which independently achieves only 12.8% on AIME25 (as noted by the paper in Section 4.2, referencing the Qwen3 technical report), still serves as an effective deliberation model, achieving 53.3% at K=16 on AIME25 when deliberating on R1-Distill-Qwen-7B's trajectories. The paper interprets this as evidence that the deliberation phase "relies more heavily on the model's ability to perform comprehensive analysis, synthesis, and summarization" rather than on "peak intrinsic reasoning power." This is a significant practical finding: it suggests organizations could use a small, fast model for parallel reasoning and a separate, potentially larger model optimized for synthesis and critique rather than raw problem-solving.

Ablation Studies and Robustness Checks

• Trajectory selection strategy (Appendix A, Figure 5): The paper compares four strategies for selecting which K trajectories (from a pool of 256) to include in the memory cache: Random, Max-Diversity (selecting trajectories with highest diversity), Max-Length (selecting longest trajectories), and Max-Answer-Num (selecting trajectories supporting the most common answer). Using R1-Distill-Qwen3-8B on AIME25 and HMMT25-Feb with K ∈ {8, 16, 32, 64}, Max-Answer-Num significantly outperforms all other strategies, with accuracy approximately 10–15 percentage points higher than Random selection at K=64. Max-Length performs worst, suggesting that longer outputs introduce noise rather than signal. Max-Diversity performs comparably to Random, indicating that explicitly maximizing diversity provides no marginal benefit over natural sampling diversity. The practical implication: pre-filtering parallel trajectories by majority-vote consensus before deliberation provides the strongest foundation for synthesis.

• Iterative deliberation depth (Section 4.3, Figure 4): Using R1-Distill-Qwen-7B, R1-Distill-Qwen3-8B, and DeepSeek R1-0528 with K=K⁽¹⁾=...=K⁽ᴺ⁾=8 and N=4 iterations on HMMT25-Feb and GPQA-Diamond, Heavy-Mean@K consistently improves with iteration count, while Heavy-Pass@K degrades. For R1-Distill-Qwen-7B on HMMT25-Feb, HM@K rises from approximately 30% (iteration 1) to approximately 38% (iteration 4); HP@K falls from approximately 60% to approximately 48%. For DeepSeek R1-0528 on GPQA-Diamond, HM@K rises from approximately 88% to approximately 94%; HP@K remains roughly flat at 94–95%. This trade-off is consistent across models and benchmarks, establishing a robust empirical pattern: iterative refinement improves average output quality at the cost of output diversity, reducing the chance of a breakthrough synthesis.

• Cross-model pairing (Section 4.2, Figure 3): As described in the main results above, all deliberation model choices produce HM@K > M@K. The deliberation stage is robust to the choice of deliberation model insofar as it does not require a model with high independent task accuracy, but performance does vary with deliberation model capability: R1-Distill-Qwen3-8B (a specialized reasoning model) consistently produces the highest HM@K when deliberating on R1-Distill-Qwen-7B trajectories, while Qwen2.5-32B-Instruct (a general instruction model with lower independent accuracy) produces lower HM@K. The gap between the best and worst deliberation model is approximately 5–9 percentage points at K=16 on AIME25 and HMMT25-Feb.

• Tool-interleaved vs. standard heavy thinking (Section 4.4, Table 3 vs. Table 1): On AIME25 with the same models (Qwen3-8B, Qwen3-32B, GPT-OSS-20B), tool-interleaved heavy thinking achieves substantially higher HM@4 than standard heavy thinking. For GPT-OSS-20B, standard HM@4 at K=8 is 92.5 (Table 1); tool-interleaved HM@4 is 90.0 (Table 3)—slightly lower, though note that Table 3 uses V@4 as the comparison while Table 1 uses V@K with K=8, making direct comparison imperfect. For Qwen3-8B, standard HM@4 is 80.0 (Table 1); tool-interleaved HM@4 is 76.7 (Table 3). However, the baseline-adjusted gain (HM@4 minus V@4) is larger in the tool-interleaved setting: on HMMT25, GPT-OSS-20B shows HM@4 − V@4 = 85.7 − 73.3 = 12.4 percentage points (Table 3) versus the standard setting where HM@4 − V@K for comparable models is typically 2–8 percentage points (Table 1). This suggests that external execution feedback amplifies the deliberation model's ability to discriminate correct from incorrect trajectories.

• Training stability with context length (Appendix B, Figure 6): The RLVR experiments using R1-Distill-Qwen-7B with VeRL and GSPO on AIME25 and HMMT25-Feb test two configurations: K=8 and K=16 parallel trajectories in the training data. The K=8 configuration trains stably, with HM@4 improving approximately 10% over the first 100 steps on both training and test sets. The K=16 configuration shows initial improvement but then experiences "significant entropy collapse after 100 steps" —a sharp drop in response entropy indicating mode collapse where the model loses diversity in its outputs. The paper attributes this to sequence length limitations causing truncated training signals. This is a critical negative result: it establishes that internalizing heavy thinking through RLVR is possible at moderate context lengths (K=8) but currently unstable at larger scales (K=16), constraining the practical scope of the internalization thesis.

• Difficulty-dependent corrective capability (Section 4.1, Figure 2): As described above, the distributional analysis of heavy pass rate against parallel pass rate provides the paper's only systematic ablation of when heavy thinking works as a corrective mechanism versus when it merely preserves existing accuracy. The finding that ~1,400 queries with parallel pass rate <0.5 remain unresolved despite deliberation confirms that heavy thinking cannot correct all errors—its corrective capability has a ceiling that depends on whether the deliberation model can identify common failure modes from the available trajectories.

Critical Assessment

Does heavy thinking consistently outperform Best-of-N (majority voting)? The paper claims that "heavy thinking consistently outperforms traditional Best-of-N strategies" (Abstract, Introduction). The evidence provides qualified support. On STEM benchmarks where the model is not near saturation (BeyondAIME, HMMT25-Feb, GPQA-Diamond for mid-capability models), HM@4 exceeds V@K by margins of 2–10 percentage points (Table 1). On AIME25, where many frontier models are near ceiling, the advantage is smaller or occasionally reversed (e.g., DeepSeek R1-0528 at K=8: HM@4 = 93.3, V@K = 90.0—a 3.3-point gain; at K=16: HM@4 = 96.7, V@K = 90—a 6.7-point gain—though note the paper reports this as V=90 for K=16, an apparent typo since V@K=16 would be expected to exceed V@K=8). On general reasoning tasks (Table 2), the pattern is domain-dependent: strong gains on IFEval and IMO Answer Bench, mixed results on LiveCodeBench, no gains on Arena-Hard. The claim of "consistent" outperformance is therefore true for hard STEM benchmarks but overstates the universality for easy benchmarks (ceiling effects) and open-ended tasks.

Does heavy thinking approach Pass@K? The paper claims that "stronger LLMs can even approach Pass@N performance" (Abstract). The evidence provides support for frontier models, not for smaller models. For GPT-5-Thinking on AIME25 at K=16: P@K=100, HP@4=100—matching the upper bound. For Kimi K2 Thinking on AIME25 at K=8: P@K=100, HP@4=100—matching. But for smaller models, the gap is large: R1-Distill-Qwen-7B on AIME25 at K=16: P@K=66.7, HP@4=60.0 (6.7-point gap); on HMMT25-Feb: P@K=70.0, HP@4=40.0 (30-point gap). The "approaching Pass@N" claim is thus strongly model-scale-dependent: it holds for models with high intrinsic reasoning capability and collapses for smaller models, where the deliberation model cannot reliably identify or synthesize correct answers from the available trajectories.

Can heavy thinking produce correct answers not present in any trajectory (HP@4 > P@K)? This is the paper's most important mechanistic claim. The evidence provides compelling but narrow support. The IMO Answer Bench results (Table 2) are the strongest: GLM 4.6 shows HP@4=86.0 vs. P@K=75.1 (+10.9), and four of five models show positive gaps. On STEM benchmarks (Table 1), the instances of HP@4 > P@K are less dramatic and concentrated in frontier models: GPT-OSS-20B on HMMT25-Feb at K=8 shows HP@4=93.3 vs. P@K=90.0 (+3.3); AIME25 shows HP@4=96.7 vs. P@K=96.7 (ties). The paper states that HP@4 exceeds P@K "in nearly half of our experimental trials" for frontier models—an imprecise claim without detailed enumeration of which trials and under what conditions. The evidence exists, but the magnitude and reliability of the effect is not systematically characterized.

Does RLVR successfully optimize heavy thinking? The Appendix B results are preliminary and mixed. The 10% HM@4 improvement over 100 steps on a single 7B model establishes feasibility, but the entropy collapse at K=16 and the absence of results on larger models or longer training runs mean that the claim of RLVR as "a promising path toward self-evolving LLMs that internalize complex reasoning" (Abstract) is aspirational rather than demonstrated. The paper does not show that RL-trained models can perform heavy thinking without the external two-stage pipeline—internalization in the strong sense is not tested.

What the experiments do not test: Several important questions are left open. (1) Direct comparison to full orchestration frameworks. The paper argues that heavy thinking captures the essential mechanism of orchestration, but it never compares heavy thinking directly against a full multi-agent orchestration system (Claude Code, CodeX, etc.) on the same tasks. Without this comparison, the claim that the two-stage pipeline is the "minimal execution unit" remains an extrapolation. (2) Scaling beyond K=16. The experiments stop at K=16, which is a relatively modest parallelization budget. The Appendix A trajectory selection experiment goes to K=64 from a pool of 256, but HM@K results at K=64 are not reported. The scaling trends in Figure 5 suggest continued improvement but with diminishing returns—characterizing the asymptotic behavior would strengthen the scaling claims. (3) Cost-adjusted comparisons. The paper never reports accuracy per unit compute, making it impossible to assess whether heavy thinking's gains over majority voting are cost-effective. Heavy thinking at K=8, K⁽¹⁾=4 costs 12 generations versus 8 for Vote@8. The 2–10 point accuracy gains on hard STEM benchmarks must be weighed against this 50% compute increase. (4) Robustness to prompt variations. All experiments use the single deliberation prompt template from Figure 7. How sensitive are results to prompt wording? Could a simpler prompt ("Pick the best answer from these attempts") achieve similar results? This ablation is absent. (5) Test set sizes and statistical significance. AIME25 has 30 problems; HMMT25-Feb likely a similar small number. With no confidence intervals or error bars anywhere in the paper, small performance differences (1–3 percentage points) cannot be distinguished from noise. (6) The read-able skill evaluation. The paper claims the HEAVYSKILL document "functions correctly under both Claude Code and custom orchestration harnesses" (Section 2.4), but provides no quantitative evaluation of skill-mode performance versus workflow-mode performance. Whether the self-orchestration capability of frontier LLMs matches external Python pipeline orchestration is untested.

6. Limitations and Trade-offs

Cost of Difficulty Estimation vs. Cost of Execution

The assumption or constraint. The difficulty-dependent analysis in Section 4.1 (Figure 2) requires computing a "parallel pass rate" — the fraction of K=16 trajectories that are correct — for each query before deciding whether heavy thinking will help or hurt. The paper uses this to characterize when deliberation acts as a corrective mechanism (pass rate < 0.5) versus when it merely preserves accuracy (pass rate > 0.5). However, computing the parallel pass rate requires generating all K trajectories AND knowing the ground-truth answer for each (to determine correctness). The paper acknowledges this implicitly through its experimental design — the analysis uses open-resource data with known answers — but does not account for the cost of difficulty estimation in any performance or efficiency calculation.

The consequence. In a realistic deployment, the system does not know the parallel pass rate for a given query. To decide whether to activate heavy thinking, the system would either need to: (a) generate the K trajectories and score them (which is the full parallel reasoning cost already), making the "activation decision" costs equivalent to the full pipeline cost, thus negating any savings from conditional activation; (b) develop a cheaper difficulty estimator that predicts pass rate from the query text alone — which the paper does not provide. The activation conditions in the readable skill (Section 2.4) are based on high-level task type heuristics ("mathematical reasoning, complex logical deduction") rather than a query-level difficulty assessment, meaning that in practice the system pays the full heavy thinking cost on ALL queries matching those categories, regardless of whether the query would benefit. The paper's headline result that heavy thinking helps most at moderate difficulty (Figure 2) is therefore an analytical insight about what would be possible with oracle difficulty knowledge, not a deployable strategy.

What evidence exists in the paper. Figure 2 provides the evidence for difficulty-dependent efficacy but simultaneously exposes the estimation problem: the analysis depends on ground-truth pass rates computed post-hoc. Section 4.1 describes the methodology — "We randomly sample 10k queries and conduct parallel reasoning with a sampling size of K = 16 for each query to determine its baseline parallel pass rate" — which is a retrospective analysis, not a prospective deployment. The readable skill in Section 2.4 and Appendix C Figures 8-10 provides activation heuristics but no query-level difficulty estimation mechanism. The paper's RLVR experiments (Appendix B) select queries with "a pass rate in the range [0, 0.625]" for training, again using oracle knowledge of pass rates.

Mitigation status. Not addressed. The paper does not propose or evaluate a lightweight difficulty estimator. The activation conditions in the readable skill are task-type-level heuristics, not query-level difficulty predictions. The paper does not discuss this gap or flag it as future work. This is a significant omission because it means the paper's strongest analytical result — that heavy thinking is most valuable as a corrective mechanism on moderately difficult problems — cannot be operationalized without solving the difficulty estimation problem first.

Single Benchmarks, No Direct Orchestration Comparison

The assumption or constraint. The paper's central thesis is that heavy thinking is the "minimal execution unit" that drives performance in complex agentic orchestration frameworks. However, the paper never compares heavy thinking directly against any full orchestration system (Claude Code, CodeX, Hermes, etc.) on the same tasks. All experiments compare heavy thinking against baselines derived from its own parallel reasoning stage: Mean@K, Pass@K, and Vote@K. The paper evaluates on standard benchmarks (AIME25, HMMT25-Feb, GPQA-Diamond, etc.) but does not test on the types of multi-step, tool-interleaved, agentic tasks that orchestration frameworks are actually designed for. The tool-interleaved experiments in Section 4.4 add Python interpreter calls to the parallel reasoning stage but do not simulate the full orchestration pattern (role decomposition, inter-agent communication, structured planning protocols).

The consequence. The paper's core claim — that orchestration frameworks can be reduced to parallel reasoning plus deliberation — lacks the essential empirical test: a head-to-head comparison showing that heavy thinking matches or exceeds the performance of a full orchestration system. Without this, the "minimal execution unit" argument remains plausible but unproven. It is possible that orchestration frameworks derive substantial additional benefit from role specialization (different agents with different prompting, different capabilities), from structured inter-agent debate and critique, or from adaptive planning based on intermediate results — and that heavy thinking captures only a fraction of these gains. The paper's absolute performance numbers are strong (frontier models achieve near-perfect scores on AIME25), but these benchmarks may not be the tasks where orchestration frameworks provide their maximum advantage. The readable skill evaluation is also untested quantitatively: the paper states the skill "functions correctly" under Claude Code (Section 2.4) but reports no accuracy numbers for skill-mode execution, making it impossible to assess whether self-orchestration matches external pipeline orchestration.

What evidence exists in the paper. The paper provides qualitative evidence for its thesis through the readable skill portability argument (Section 2.4) — the claim that the same skill document works across different harnesses suggests the capability is not framework-specific. Table 1 provides evidence that absolute performance levels approach saturation on AIME25, suggesting the two-stage pipeline captures most of what is achievable. But neither of these is a quantitative comparison against orchestration frameworks. The tool-interleaved experiments (Table 3) are the closest approximation to agentic tasks but stop at adding code execution feedback rather than implementing multi-agent coordination.

Mitigation status. Not addressed as a limitation. The paper frames the absence of orchestration comparison as a feature — the whole point is to isolate heavy thinking FROM orchestration — but does not acknowledge that this framing makes the "minimal unit" claim untestable within the paper's own experimental design. The claim remains an assumption rather than a demonstrated result.

Inference Cost Overhead Not Accounted for in Headline Gains

The assumption or constraint. The paper compares Heavy-Mean@4 (deliberation performance) against Vote@K (majority voting on the same K parallel trajectories) and reports that heavy thinking "consistently outperforms traditional Best-of-N strategies." However, Vote@K uses K generations (the parallel trajectories) and a cheap statistical aggregation (counting answers). Heavy-Mean@4 uses K generations (parallel trajectories) PLUS K⁽¹⁾ = 4 additional generations (the deliberation outputs). At K=16, Vote@16 costs 16 generations; HM@4 costs 16 + 4 = 20 generations — a 25% compute overhead. At K=8, Vote@8 costs 8; HM@4 costs 12 — a 50% overhead. The paper never reports accuracy per unit compute, so the reader cannot assess whether the accuracy gains justify the additional cost.

The consequence. The 2–10 percentage point accuracy gains that heavy thinking achieves over majority voting on hard STEM benchmarks (Table 1) must be weighed against this compute overhead. On AIME25 with R1-Distill-Qwen-32B at K=16, HM@4 = 68.3 versus V@K = 66.7 — a 1.6-point gain for 25% more compute. On HMMT25-Feb with the same model, HM@4 = 45.8 versus V@K = 43.3 — a 2.5-point gain. On GPQA-Diamond with R1-Distill-Qwen-32B, HM@4 = 67.2 versus V@K = 66.7 — a 0.5-point gain. These marginal improvements raise the question of whether the compute would be better spent on more parallel trajectories (K=20 rather than K=16) instead of deliberation. The paper's iterative deliberation experiments (Section 4.3) incur even larger overhead: N=4 iterations at K=8 costs 8 + 4×8 = 40 generations, yet the HM@K improvements over single-pass deliberation are modest (e.g., Figure 4 shows perhaps 5–8 percentage points on HMMT25-Feb for R1-Distill-Qwen-7B going from iteration 1 to iteration 4). No cost-effectiveness analysis is provided.

What evidence exists in the paper. The generation budgets are specified throughout: K ∈ {8, 16}, K⁽¹⁾ = 4 (main experiments), K⁽¹⁾ = 8 (iterative experiments), N = 4 iterations. The total compute cost of each configuration can be computed from these numbers. Table 1 reports M@K, P@K, V@K, HM@4, and HP@4 — enabling a reader to compute accuracy-per-generation if desired, but the paper never does so itself. There are no efficiency curves (accuracy vs. FLOPs or accuracy vs. cost) anywhere in the paper.

Mitigation status. Not addressed. The paper treats generation count as a configuration parameter rather than a cost that should be optimized. There is no discussion of compute-normalized evaluation, no efficiency metrics, and no suggestion that future work should investigate the cost-effectiveness tradeoff of deliberation versus additional parallel sampling.

No Statistical Significance or Confidence Information

The assumption or constraint. All experimental results in Tables 1-3 and Figures 2-6 are reported as point estimates without confidence intervals, error bars, standard deviations, or significance tests. The test sets for AIME25 (30 problems), HMMT25-Feb (likely 30-60 problems), and other benchmarks are small, making point estimates noisy. The two-fold cross-validation protocol used in the reference example paper's compute-optimal scaling analysis is absent here.

The consequence. Small performance differences — 1-3 percentage points on a 30-problem test set — cannot be reliably distinguished from sampling noise. For example, on AIME25 with R1-Distill-Qwen-7B at K=16, HM@4 = 56.7 versus V@K = 60.0 — a 3.3-point gap that could represent genuine underperformance or could be a 1-question swing on a 30-question set. On GPQA-Diamond with GPT-OSS-20B at K=8, HM@4 = 67.5 (Table 1) — does this differ from a hypothetical V@K that is not reported? The absence of variance estimates means the paper cannot make nuanced comparisons between models, between methods, or between K=8 and K=16. Claims about performance hierarchies ("Heavy-Pass@k ≥ Heavy-Mean@K ≥ Vote@K ≥ Mean@k") may hold in expectation but the paper provides no evidence that the observed ordering at specific benchmarks is statistically reliable.

The RLVR training curves in Figure 6 (Appendix B) show training and test set trajectories without shaded regions for variance across runs or seeds. The claim of a "consistent upward trend" with a "further improvement of approximately 10%" is based on a single training run whose stability at K=8 versus collapse at K=16 is presented without replication. In reinforcement learning experiments, where results are notoriously seed-sensitive, single-run reporting is insufficient to establish reliability.

What evidence exists in the paper. The paper provides detailed numerical results (Tables 1-3) and line plots (Figures 2-6) with specific accuracy values reported to one decimal place, which creates an impression of precision. But nowhere are confidence intervals computed or statistical tests applied. The cross-model pairing experiments (Figure 3), iterative deliberation experiments (Figure 4), trajectory selection ablation (Figure 5), and RLVR experiments (Figure 6) all report single-run outcomes without variance estimates.

Mitigation status. Not addressed. The paper does not discuss test set sizes, does not compute confidence intervals, and does not acknowledge this as a limitation. The inclusion of 17 model configurations across multiple benchmarks provides some qualitative robustness (patterns that appear consistently across models are more trustworthy), but this is not a substitute for quantitative uncertainty quantification.

No Systematic Ablation of the Deliberation Prompt Design

The assumption or constraint. The sequential deliberation stage uses a single, carefully designed prompt template (Figure 7, Appendix C) that includes multiple specific instructions: classify query type, summarize thinkers' approaches, analyze differences, apply critical thinking rather than naive majority voting, re-derive when all thinkers are wrong, produce summary before answer, and follow format conventions. The paper attributes the deliberation model's ability to synthesize cross-trajectory insights and to exceed Pass@K to this process — the model functions as an "implicit verifier" that "explicitly compare[s] trajectory differences during deliberation" (Section 3.2).

The consequence. Without ablating the prompt components, it is impossible to know which instructions are load-bearing and which are incidental. Does the critical thinking instruction ("But you can't do it so superficially") actually change model behavior, or would a simpler prompt ("Here are multiple solutions to this problem. What is the correct answer?") achieve similar results? Does the requirement to produce a summary before the answer improve synthesis quality, or does it merely consume tokens? Could the gains over majority voting be achieved by a simpler selection mechanism — for instance, prompting the model to rank the K trajectories and pick the best one? The paper's qualitative claim that the model functions as an "implicit verifier" is an interpretation of observed outcomes, not a demonstrated mechanism. Without prompt ablation, the paper cannot distinguish between "the deliberation model is genuinely synthesizing" and "the deliberation model is performing sophisticated selection that happens to sometimes produce novel answers."

This is particularly important for the key finding that HP@4 can exceed P@K — evidence that deliberation produces answers not present in any input trajectory. If this effect depends critically on specific prompt phrasing (e.g., "If you realize that none of these thinkers have answered correctly, you can even learn from the wrong experiences"), then the finding may not transfer to slightly different prompt formulations, making the method fragile in ways the paper does not document.

What evidence exists in the paper. The prompt template is provided in full (Figure 7), and the readable skill (Figures 8-10) includes a deliberation prompt framework that is structurally similar but not identical. However, the paper conducts zero prompt ablation experiments. There are no experiments comparing the full deliberation prompt against a reduced version (e.g., without the re-derivation instruction, without the critical thinking warning, without the summary requirement). The cross-model pairing experiments (Section 4.2, Figure 3) test different deliberation models but use the same prompt, so they test robustness to model choice but not to prompt design.

Mitigation status. Not addressed. The paper treats the deliberation prompt as a fixed component of the framework rather than a variable to be studied. The portability of the readable skill across harnesses (Section 2.4) provides some evidence of robustness to the execution environment, but the skill uses the same deliberation prompt structure. No future work is suggested on prompt optimization or on understanding which components of the deliberation instruction are essential.

Hard Problems Remain Unsolved — Heavy Thinking Cannot Create Capability

The assumption or constraint. The heavy thinking framework is fundamentally bounded by the quality of the parallel reasoning trajectories. The deliberation model can synthesize, compare, and re-derive, but it cannot conjure correct reasoning from input trajectories that are all fundamentally wrong in ways the deliberation model cannot diagnose. The paper acknowledges this implicitly throughout but characterizes it most directly in Section 4.1 (Figure 2): for queries with parallel pass rate below some threshold (approximately the <0.125 bin implied by the lowest bracket), heavy thinking provides limited corrective capability — "approximately 1,400 queries remain unresolved" despite deliberation. Similarly, in the introductory discussion of cross-model pairing (Section 4.2), the paper notes that even when the deliberation model is effective, the baseline M@K (the mean accuracy of the parallel trajectories) sets a lower bound on what is achievable.

The consequence. Heavy thinking cannot solve problems that are genuinely outside the base model's capability distribution. If the model has no conception of the correct approach — if all K trajectories make the same fundamental conceptual error, or if the problem requires knowledge the model lacks — deliberation cannot recover. This is the same boundary condition identified in the compute-optimal test-time scaling literature (the reference example paper): test-time compute amplifies existing capability but does not create it. The paper's results confirm this pattern: the hardest problems (implicitly those in the "unresolved" category of Figure 2) see minimal benefit from heavy thinking regardless of K or iteration count.

This limitation is particularly consequential for the paper's internalization thesis. If heavy thinking is trained into model parameters through RLVR (Appendix B), the resulting model might exhibit the heavy thinking pattern on all queries, including those where it provides no benefit, wasting inference compute without accuracy gain. Without a mechanism for the model to recognize when heavy thinking is futile and fall back to a single trajectory, the internalized capability could become a cost burden on easy and impossible problems alike.

What evidence exists in the paper. Figure 2 provides the most direct evidence: the ~1,400 unresolved queries in the low pass-rate regime represent problems where deliberation fails to recover correct answers. The absolute performance on the hardest benchmark (BeyondAIME) for smaller models — R1-Distill-Qwen-7B achieves Heavy-Pass@4 = 45.0 at K=16 (Table 1) — shows that even the best deliberation output misses the correct answer on 55% of problems. The RLVR experiments (Appendix B, Figure 6) show training instability at K=16 but do not test whether RL-trained models maintain the ability to recognize when deliberation is unnecessary. The readable skill (Section 2.4) includes activation conditions that attempt to filter tasks by type, but these are coarse heuristics that would not distinguish between an easy AIME problem and a hard AIME problem within the same benchmark.

Mitigation status. Partially addressed through task-type-level activation conditions in the readable skill (Section 2.4), which specify that heavy thinking should NOT be activated for "simple factual questions" or "casual conversation." However, these conditions filter at the task category level, not at the individual query difficulty level. Within a category where heavy thinking is activated (e.g., mathematical reasoning), there is no mechanism for detecting that a specific problem is too hard for the model and that deliberation will not help. The paper flags this implicitly in the conclusion — "In the future, we aim to conduct a more granular analysis" — but does not propose a solution.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper shifts the conversation around agentic orchestration frameworks from system design toward capability identification. Prior to this work, the dominant paradigm treated orchestration frameworks—Claude Code, CodeX, Hermes, OpenClaw—as architectures to be built: add more agents, more handoff protocols, more skill libraries, more memory components, more communication channels. The implicit assumption was that each additional component contributed nontrivially to the performance observed on complex reasoning tasks, and that the complexity of the system was an inescapable cost of the capability. The paper challenges this assumption directly by demonstrating that the core cognitive operation—parallel reasoning followed by sequential deliberation—can be isolated, studied independently, deployed without any orchestration scaffolding, and packaged as a portable, readable skill that transfers across harnesses.

This is not a paradigm shift in the Kuhnian sense—the heavy thinking pattern was already emerging independently in frontier systems (Gemini, Kimi K2, PaCoRe). Rather, it is a reframing that has substantial practical consequences. It transforms the field's orientation from "how do we build better agent frameworks?" to "what is the minimal cognitive unit that drives performance, and how do we internalize it?" The distinction matters because it redirects research investment: if the two-stage pipeline captures the essential mechanism, then incremental improvements to orchestration scaffolding (better role decomposition, more elaborate communication protocols) may yield diminishing returns compared to optimizing the core operation itself—better deliberation prompts, better trajectory diversity mechanisms, and ultimately, internalization through training.

The paper also provides a resolution to an implicit tension in the literature. Parallel reasoning approaches like Group Think (Hsu et al., 2025) and tree-search methods like Tree of Thoughts (Yao et al., 2023) generated multiple reasoning paths but typically relied on heuristic selection (voting, verifier scoring) rather than genuine synthesis. The paper shows that synthesis—not just selection—is the mechanism through which heavy thinking exceeds Vote@K and, in frontier models, approaches or exceeds Pass@K (Table 1, Section 3.2). This explains why prior parallel reasoning methods that stopped at aggregation saw more modest gains: they were leaving the most powerful capability—cross-trajectory insight synthesis—on the table. Conversely, prior work that found self-correction ineffective (Huang et al., 2023, cited in the reference example) was likely testing on difficulty regimes where the base model's trajectories were all wrong in ways the model could not diagnose—exactly the regime where Figure 2 shows heavy thinking provides limited corrective benefit (~1,400 queries remaining unresolved). The paper's difficulty-dependent analysis (Section 4.1) provides a framework for understanding when synthesis works (moderate difficulty, pass rate 0.125–0.5) and when it doesn't (very hard problems, pass rate near 0), reconciling these conflicting prior findings.

The research landscape is redrawn in two concrete ways. More attractive: systematic study of deliberation mechanisms (prompt design, error-mode detection, cross-trajectory synthesis), training methods that internalize the two-stage pipeline (RLVR on heavy thinking trajectories), and lightweight difficulty estimation to enable conditional activation of heavy thinking. Less attractive: incremental additions to multi-agent orchestration frameworks that do not demonstrate gains beyond what a simple parallel-then-deliberate pipeline achieves—the burden of proof has shifted. Future orchestration work must now demonstrate that its additional complexity provides value over and above the heavy thinking baseline, not merely that the framework as a whole performs well.

Follow-Up Research This Work Enables

Prompt ablation to identify the active ingredients of deliberation. The paper uses a single, complex deliberation prompt (Figure 7 in Appendix C) with multiple components: a summary-before-answer requirement, an explicit instruction against naive majority voting, a permission to re-derive when all trajectories are wrong, and format consistency instructions. No ablation exists. A natural follow-up would systematically remove or vary each component and measure the impact on HM@4 and HP@4 across difficulty levels. The critical question is whether the "re-derive when all wrong" instruction drives the HP@4 > P@K effect, or whether the effect emerges from the model's general synthesis capability regardless of prompt phrasing. A strong study would test at least four prompt variants: (a) the full prompt, (b) the full prompt minus the re-derivation permission, (c) a minimal prompt ("Here are K solutions. What is the correct answer?"), and (d) a selection-only prompt ("Which of these solutions is correct? Output only the answer."). Testing across a difficulty-stratified sample (parallel pass rate bins as in Figure 2) would reveal whether prompt design matters uniformly or only in specific regimes. This is directly tractable using the paper's existing infrastructure and benchmark suite.

Heavy thinking versus full orchestration on agentic benchmarks. The paper's central thesis—that heavy thinking is the minimal execution unit driving orchestration performance—remains untested against actual orchestration frameworks. A critical follow-up would run a head-to-head comparison on benchmarks designed for agentic evaluation: multi-step tool-use tasks, long-horizon planning problems, or the kinds of compound tasks described in agent framework documentation. The comparison would pit the HEAVYSKILL pipeline (parallel reasoning + deliberation, no multi-agent structure) against a representative orchestration framework (Claude Code or an open-source equivalent) on identical problems, measuring both accuracy and inference cost (total tokens, wall-clock time, API calls). If heavy thinking matches or exceeds the full framework, the "minimal unit" thesis is validated and the field should redirect effort toward optimizing the core cognitive operation. If orchestration substantially outperforms heavy thinking, the thesis is falsified and the paper's claims must be scoped to the specific benchmarks where heavy thinking was evaluated. The paper's readable skill (Section 2.4) makes this experiment straightforward: the same skill can be loaded into the orchestration framework, enabling a fair comparison where both systems have access to the same heavy thinking capability, with the only difference being the orchestration scaffolding.

Lightweight difficulty estimation for conditional activation. The paper's strongest analytical result (Figure 2) shows that heavy thinking is most valuable as a corrective mechanism on moderately difficult problems (parallel pass rate 0.125–0.5) and merely preserves accuracy on easy problems (pass rate >0.5) while having minimal impact on very hard ones. However, the parallel pass rate requires generating all K trajectories and knowing the ground truth—completely impractical for deployment. A critical follow-up would train a difficulty classifier that takes only the query text (or the first few trajectories' verifier scores, in domains with verifiable answers) and predicts which difficulty bin the query falls into. The training data already exists: the 10K-query dataset used in Figure 2 provides labeled difficulty bins. A lightweight classifier (e.g., a fine-tuned small model or even a prompted few-shot classifier) could be evaluated on its ability to route queries: activate heavy thinking for predicted moderate-difficulty queries, skip it for predicted easy or very hard queries. The evaluation metric would be accuracy-per-unit-compute, comparing the conditional strategy against always-on heavy thinking and never-on baseline. This would directly operationalize the paper's most important descriptive finding.

Scaling the width-depth tradeoff at larger K and N. The paper explores width (K) only up to 16 in the main experiments and up to 64 in the trajectory selection ablation (Appendix A, Figure 5), and depth (N) only up to 4 iterations on 8-trajectory caches (Section 4.3). The width-depth tradeoff—width improves both Heavy-Mean and Pass@K while depth improves Heavy-Mean but degrades Heavy-Pass—is observed but not systematically characterized as a function of total compute budget. A natural follow-up would run a grid sweep over wider ranges of K and N at fixed total generation budgets, producing an "iso-cost" map showing which (K, N) pairs maximize Heavy-Mean@K and which maximize Heavy-Pass@K at each budget level. This would establish whether a compute-optimal allocation strategy exists—analogous to the reference example paper's compute-optimal test-time scaling, but for the width-depth tradeoff rather than the search-vs-revision tradeoff. The paper's existing framework and benchmarks support this experiment directly.

RLVR at scale with context-length solutions. The RLVR experiments (Appendix B, Figure 6) are the paper's most forward-looking contribution but also its most fragile: training on K=16 trajectories caused entropy collapse attributed to context length limitations, while K=8 trained stably but showed only a 10% HM@4 improvement. A critical stress-test would replicate the RLVR experiments on a model with larger native context length (e.g., 128K or 1M tokens) and on larger base models (32B, 70B) to determine whether the context-length bottleneck is fundamental or can be engineered around. The specific research question is: at what model scale and context length does RLVR on heavy thinking trajectories become stable for K=16 or K=32, and what HM@4 gains are achievable with longer training? Additionally, does the RL-trained model internalize the two-stage pattern—can it perform parallel reasoning and deliberation without the external pipeline, simply through its own generation? Testing this would require evaluating the RL-trained model in a single-pass setting (no external orchestration) and comparing its chain-of-thought structure to the explicit two-stage pattern from the training data.

Cross-domain replication with domain-specific deliberation prompts. The paper shows that heavy thinking benefits vary dramatically across task types: strong gains on IFEval and STEM, marginal on Arena-Hard, mixed on LiveCodeBench (Table 2). But all experiments use essentially the same deliberation prompt structure (Figure 7). A follow-up would develop domain-adapted deliberation prompts—e.g., for code, emphasizing test-case verification and algorithmic complexity analysis; for open-ended tasks, emphasizing stylistic coherence and constraint satisfaction rather than correctness—and measure whether domain-adapted prompts close the gap on weakly-performing domains. The finding that Arena-Hard sees minimal gains might reflect a fundamental limitation (subjective preference tasks don't benefit from parallel-then-deliberate) or might reflect a prompt mismatch that could be engineered around. Distinguishing these cases would clarify the scope of heavy thinking's applicability.

Practical Applications and Downstream Use Cases

Cost-efficient batch evaluation for model benchmarking. Organizations that regularly evaluate LLMs on reasoning benchmarks (AIME, GPQA, HMMT) for model selection or monitoring can immediately deploy the heavy thinking pipeline as a drop-in accuracy booster. For frontier models like GPT-5-Thinking or Kimi K2 Thinking, running K=8 parallel trajectories with deliberation (12 total generations) can achieve HM@4 scores within 3–5 percentage points of saturation on AIME25 and HMMT25-Feb (Table 1), approaching what would otherwise require K=16 or K=32 with majority voting. This represents a 25–60% reduction in inference cost for a given accuracy target when benchmarking frontier models. For mid-capability models (~32B distilled models), the gains are larger on hard benchmarks: on HMMT25-Feb, R1-Distill-Qwen-32B achieves HM@4 = 45.8 at K=16, exceeding Vote@16 = 43.3 (Table 1), a meaningful improvement for models where every percentage point matters. The pipeline requires no model fine-tuning and can be implemented as a wrapper around any existing API or local inference setup using the prompt templates in Figure 7 and the formatting code in Figure 7.

Data generation for self-improvement and distillation pipelines. When using LLMs to generate training data—for supervised fine-tuning, rejection sampling, or RLVR—the quality of generated solutions directly determines downstream model performance. The heavy thinking framework offers a concrete recipe for improving generation quality: for each training query, run K parallel trajectories, feed them through deliberation, and use the deliberation output (or its best variant, HP@4) as the training target rather than a single greedy or sampled trajectory. The paper's results on IFEval are particularly striking: HP@4 = 97.6 for GPT-OSS-20B versus P@K = 90.8 (Table 2), meaning deliberation produces near-perfect solutions on a benchmark where 9% of parallel trajectories are completely wrong. Applying this to a training set of 10K–100K queries would substantially improve the quality of generated training data, potentially reducing the amount of data needed to reach a target downstream accuracy. The cost overhead—4 additional deliberation generations per query—is modest compared to the cost of generating the parallel trajectories, and is easily parallelized.

On-device or edge deployment with asymmetric model pairing. The paper's finding that a weak deliberation model (Qwen2.5-32B-Instruct, 12.8% AIME25 accuracy) can effectively synthesize trajectories from a stronger generation model (R1-Distill-Qwen-7B, ~43% accuracy) enables an asymmetric deployment architecture. A small, fast, cheap model can be deployed on-device or at the edge for the parallel reasoning stage, generating K=8 or K=16 trajectories locally with minimal latency and no API cost. These trajectories are then sent to a larger, more capable deliberation model (hosted in the cloud or on a more powerful local server) that performs the synthesis step and returns the final answer. The total bandwidth is K trajectories' worth of tokens (which can be compressed by truncating verbose chain-of-thought, as the paper's pruning mechanism already does), and the deliberation model sees all trajectories at once in a single API call. For applications like on-device coding assistants or math tutoring where users tolerate modest latency, this architecture provides strong-model quality at weak-model cost for the dominant fraction of the inference budget (the parallel generations). The paper's cross-model pairing results in Figure 3 directly inform the model selection for both stages.

Skill-based augmentation of existing agentic deployments. Organizations already running orchestration frameworks (Claude Code, Hermes, custom harnesses) can inject the HEAVYSKILL readable skill document (Appendix C, Figures 8-10) as a drop-in capability without modifying their infrastructure. The skill activates conditionally based on task type (mathematical reasoning, complex logic, code competition) and remains dormant for simple queries, so it does not impose overhead on tasks where heavy thinking provides no benefit. The skill has been verified to work under Claude Code and custom harnesses (Section 2.4), reducing integration risk. For deployment teams, this means they can immediately test whether heavy thinking improves their specific task distribution by adding a single skill file to their existing harness, rather than building a custom parallel-then-deliberate pipeline. If the skill-mode performance matches or approaches the workflow-mode performance reported in Tables 1–3, this provides rapid access to the accuracy gains without engineering investment. The conditional activation based on task type (Section 2.4) provides a coarse but practical filter that avoids wasting deliberation compute on factual lookups or casual conversation.