HEAVYSKILL: Internalizing "Heavy Thinking" as the Core of Agentic Intelligence
HeavySkill: Heavy Thinking as the Inner Skill in Agentic Harness
The paper introduces HEAVYSKILL, a framework that conceptualizes "heavy thinking" as an internal skill for LLM agents rather than just an external orchestration layer. It utilizes a two-stage pipeline—Parallel Reasoning followed by Sequential Deliberation—to achieve state-of-the-art results in complex reasoning tasks across STEM and coding domains.
TL;DR
The research community has long viewed AI agents as an assembly of "parts"—an LLM core surrounded by orchestrators, tools, and memory. HEAVYSKILL flips this script. It argues that the complex orchestration we see in frameworks like Claude Code is actually a manifestation of an inner model skill: Heavy Thinking. By formalizing this as a two-stage process of parallel reasoning and sequential deliberation, the authors demonstrate that LLMs can go beyond simple majority voting to "re-reason" their way to correct answers, even when most initial attempts fail.
Problem & Motivation: Beyond the Brittle Scaffolding
Current agentic frameworks are often "noisy." They rely on intricate system designs where the LLM is forced to act as multiple agents. While effective, the logic is often hard-coded into the system rather than the model.
The authors identify a critical gap in Test-Time Scaling (TTS). Most current methods use Majority Voting (Best-of-N), which is a "dumb" statistical consensus. If a model generates 10 paths and 7 are wrong but identical, the model fails. The core insight of HEAVYSKILL is that a sufficiently powerful LLM can act as its own judge, identifying the "golden needle" of a correct reasoning path hidden within a haystack of incorrect trajectories.
Methodology: Parallelize, Cache, and Deliberate
The HEAVYSKILL framework operates through a clean, two-phase pipeline:
- Parallel Reasoning: The model generates independent trajectories for a problem .
- Sequential Deliberation: A "summary" model (which can be the same model or a larger one) reads a Serialized Memory Cache of all previous attempts.
The Secret Sauce: Serialized Memory Cache
To avoid context window explosion, the system prunes and shuffles trajectories. This prevents the model from developing positional bias (e.g., always favoring the first or last trajectory). The deliberation phase is not just a summary; it’s a System 2 process where the model is explicitly told to:
- Evaluate the logical consistency of each "thinker."
- Identify contradictions between trajectories.
- Re-derive the solution if all thinkers appear flawed.
Experiments: Breaking the "Voting" Ceiling
The researchers tested HEAVYSKILL across demanding benchmarks like AIME25 (Arithmetic), GPQA (Science), and LiveCodeBench (Coding).
Key Findings:
- Heavy-Mean (HM) > Majority Vote (V): Simply thinking about the different paths is consistently better than just counting them.
- Scaling Depth: Introducing Iterative Deliberation (where the model reviews its own summaries) creates a scaling law for inference—the more it iterates, the higher the accuracy (though entropy collapse remains a challenge).
- The Power of Deliberation: Even when a model isn't "stronger" in terms of raw knowledge (like Qwen2.5-32B vs. specialized R1 models), if it has high instruction-following capabilities, it can be an elite "Deliberator."
Critical Analysis: Can We Learn to Think Heavily?
The most exciting part of this paper is the exploration of RLVR (Reinforcement Learning from Verifiable Rewards). The authors show that we can train models to be better deliberators. By rewarding the model when its final synthesized answer is correct (even if the input trajectories were messy), the model learns the "skill" of auditing reasoning.
Limitations
- Inference Cost: Heavy thinking is computationally expensive. The "Activation Conditions" in the HEAVYSKILL document are crucial—you don't want to use 16 parallel paths to answer "What is 2+2?".
- Noise Accumulation: In the iterative phase, the model sometimes gets "distracted" by its previous incorrect summaries, leading to a drop in the theoretical Pass@K.
Conclusion: A New Paradigm for Agents
HEAVYSKILL suggests that the future of AI agents isn't just better tools or bigger memories, but better internalized reasoning protocols. By treating "Heavy Thinking" as a learnable skill, we move closer to models that don't just guess based on probability, but deliberately verify and synthesize their way to the truth. For developers, this means the "agent harness" of the future may be a single, structured prompt or a specialized RL-tuned weight set rather than thousands of lines of orchestration code.