Agent quality comes from parallel reasoning and merging, not orchestration

A near-cult of engineering complexity has grown up around modern LLM agent systems. Orchestrators, sub-agents, memory, skill libraries, tool calls — it all looks impressive, and it leaves the important question unanswered: what actually produces the gain in quality?

When thinking longer stops being enough

The authors of HeavySkill: Heavy Thinking as the Inner Skill in Agentic Harness take an unexpectedly sober view. The real secret may not be a clever scaffold of components but a simpler internal capability of the model: first generate several independent lines of reasoning, then merge them into a final answer with some judgement. The researchers call this heavy thinking, and they show that this pattern sits behind many successful agentic schemes.

This is more than a neat turn of phrase. The paper matters because it moves the conversation about the magic of agents onto much more practical ground: which inference-time compute actually pays for itself, how to scale it, and whether this mode can be turned into a portable skill rather than a brittle layer of code and prompts.

What HeavySkill is and how it works

The core idea is simple and strong. The authors reduce a complicated agent loop to two steps:

1. Parallel reasoning — the model generates several independent solution trajectories for the same task.

2. Sequential deliberation — then another model, or the same one, reads through those trajectories, compares them, discards the weak ones and synthesizes the final answer.

In other words, instead of a single attempt you get a small newsroom of thoughts: several writers file their versions, and an editor assembles the final text.

What matters here is that the authors do not reduce all of this to plain voting. A simple majority is a crude heuristic: if three weak trajectories repeat the same mistake, voting locks the mistake in. In HeavySkill the second stage is meant to count no votes but to weigh the arguments. The paper says so directly: at the merge step, strong models can act as implicit verifiers — they notice where the trajectories differ and pick the most convincing answer rather than the most popular one.

Another engineering-relevant piece is the memory cache. Full reasoning trajectories are too long, so they are serialized and partly truncated to fit the context window. The model at the second step then receives a compact case file holding several versions of the solution.

A separate contribution is turning the whole process into a readable skill for agentic systems. Rather than an external program hard-wiring the calls, the model itself can be handed a text instruction: when to switch on heavy thinking, how to launch the parallel thinkers, how to merge their results and in what format to return the answer. That is a meaningful shift: the authors ask us to see heavy thinking not as an infrastructure trick but as an internal skill of the model.

How they tested it

The experimental section is large. The researchers run the approach on several kinds of task:

They compare several metrics. The baselines:

And the metrics specific to HeavySkill:

The comparison is set up carefully. The authors do not simply say they ran a lot of samples and things got better. They are trying to work out how well the second stage extracts the hidden value sitting in a pile of raw attempts.

The main result: merging beats picking the best answer

On the STEM benchmarks HeavySkill is convincing. The authors show a stable ordering: heavy thinking usually beats the trajectory average, beats voting, and often comes close to the ceiling set by Pass@K. Which means that if the right solution flickered anywhere in the parallel attempts, a good merge stage can often pull it out.

What is especially interesting is that with strong models the final result sometimes runs almost flush against the Pass@K ceiling. Put plainly: if the model can solve the task correctly even occasionally, heavy thinking makes it do so noticeably more consistently.

One of the most substantive parts of the paper asks whether sequential deliberation can repair weak parallel reasoning. The authors group tasks by how often a correct trajectory appears in the first phase at all. It turns out that even where the initial success rate is below 50%, the second phase often rescues the task. Not always. But a noticeable share of cases gets fixed purely by comparing the attempts and deriving the answer again.

This matters more than it looks. If HeavySkill merely picked the best of the finished trajectories, it would be an expensive version of voting. But the data hints that the second phase sometimes assembles the correct solution out of fragments of different attempts — that is, it genuinely reasons rather than only ranks.

Why the second-stage model matters more than it seems

Another strong result comes from swapping models at the merge stage. The authors hold the parallel-reasoning model fixed as a weak one and vary the editor model at the second step.

The finding is telling: the quality of the final answer depends heavily on the model doing the merge. And that model does not have to be an olympiad math champion. A large, instruction-following model that is unremarkable at solving hard problems on its own can still work well as an aggregator of trajectories.

It is a subtle observation with a lot of practical value. It means the architecture can be split: one model is good at generating varied attempts, another at analyzing and merging them. For the industry that opens up a space of price-quality trade-offs. There is no need to put an equally expensive model on both steps.

Iterations help, but not for free

The authors also try repeated sequential deliberation: after the first merge, the model takes its own intermediate conclusion, adds it to the memory cache and makes another pass, then another.

Intuitively this is like a person rewriting a solution several times, trying to improve it on each pass. And indeed, on the average-quality metric the extra iterations usually help.

There is a catch: the potential ceiling drops at the same time. The researchers put this down to noise and bias accumulating in memory. Each new iteration leans not only on the original trajectories but on the already synthesized intermediate conclusions. If a skew crept into those, it can start reinforcing itself.

This is one of the paper's most honest moments. The authors do not sell HeavySkill as a universal button marked add compute, get a perfect answer. They show a real trade-off: more depth does not always mean a better final solution space.

Where the approach helps, and where it doesn't

On tasks with a clear correctness criterion — math, code, formal instructions — HeavySkill performs best. That follows: when you can judge objectively which trajectory is better, the merge stage has something solid to stand on.

On tasks like Arena-Hard, where much of the score rides on preference, style and how human the answer feels, the gains are more modest. There you cannot simply declare one trajectory right and another wrong, so the payoff from analytical merging shrinks.

That is an important practical conclusion. Heavy thinking is not a general-purpose amplifier for any piece of text. It works best where there is structure, constraints and verifiability. For agents that write code, solve problems, follow formats and work with tools, that is good news.

The tool-use results are strong too: when the parallel trajectories can call Python and get feedback, the merge stage knows how to use those signals and beats ordinary voting. For agentic systems this is arguably one of the paper's most practically important pieces.

Reinforcement learning: the next step, with caveats

The authors go further and ask: if heavy thinking is a skill, can it be strengthened deliberately through reinforcement learning? Preliminary experiments say yes. The gain is clearest on Heavy-Mean@4 — roughly 10% in the early phase of training.

Stability is another matter. With more parallel trajectories, training starts to collapse, probably because of over-long contexts and sequence-length limits. On this front the paper opens a direction rather than offering a finished recipe.

And that is probably the right way to frame the question. If today's agent scaffolds look too brittle and too dependent on hand-written orchestration, the idea of baking heavy thinking into the model's parameters through reinforcement learning is appealing. Instead of an external conductor running the ensemble, the model learns to play in time by itself.

Why this paper matters

HeavySkill's strength is not only in the numbers. The paper helps rethink a whole class of current systems. Instead of arguing endlessly about which orchestrator is more fashionable and which agent has the prettier call graph, the authors propose isolating a basic computational primitive: several independent attempts plus a smart merge.

That is useful on three levels at once.

First, scientifically: it becomes clearer which mechanism actually drives quality up.

Second, in engineering terms: you can design simpler, more portable systems that are not tied to one particular framework.

Third, at the product level: there is a realistic way to buy quality with extra inference-time compute, without retraining the whole model.

The takeaway

HeavySkill is one of those papers that promise no magic and instead strip the excess magic off systems we already have. Its central claim sounds almost modest: the success of agentic LLMs may rest not on elaborate orchestration in itself but on a well-scaling skill of heavy thinking — parallel reasoning followed by a considered merge.

That is exactly why the work deserves attention. It suggests the future of agentic systems may lie not in ever more tangled control loops but in a more deeply internalized ability to compare, criticize and synthesize the model's own attempts.

It is not a silver bullet yet: the approach works better on verifiable tasks, suffers with long contexts and demands a careful choice of model for the second stage. But as a research frame and an engineering principle, HeavySkill is a strong move. In short, the paper asks us to see agency not as a layer bolted on top but as a form of organized internal thinking. And that is a far more fundamental idea than yet another orchestrator.