Can voting work at every level of task decomposition, not just whole problems?
This explores whether majority voting — the trick of sampling an answer several times and keeping the consensus — still pays off when you apply it to the small sub-steps of a problem rather than only voting on the final whole-problem answer.
This reads the question as asking whether voting belongs at the *granular* level — inside each decomposed subtask — instead of just being a final-answer tiebreaker. The corpus has a striking direct answer: yes, and pushing voting down to the smallest steps can be more powerful than voting at the top. The clearest case is MAKER, which solves million-step tasks with zero errors by chopping problems into minimal subtasks and voting *at every single step*, flagging correlated errors as it goes Can extreme task decomposition enable reliable execution at million-step scale?. The surprise there is the inversion of intuition: once decomposition is extreme enough, small non-reasoning models suffice, because per-step voting catches the errors that would otherwise compound across a long chain. Voting isn't a finishing move; it's an error-correction primitive you can sprinkle anywhere granularity allows.
But the corpus also tells you *when* step-level voting stops being the right tool — which is the part you didn't know you wanted to know. Parallel voting fundamentally cannot manufacture sequential reasoning. On compositional tasks like graph connectivity, chain-of-thought beats parallel voting by an exponential margin, because the answer genuinely requires accumulating intermediate results in order, and no amount of independent re-sampling reconstructs that dependency When does sequential reasoning beat parallel voting?. So the honest answer to 'voting at every level' is: voting works wherever a subtask is *independently verifiable*, but where a step's value is the chain it feeds, you need sequence, not consensus. This maps onto the delegation literature, which names verifiability as the foundational axis — the thing that determines whether a subtask's output can be evaluated at all, and therefore whether voting can even score it What makes delegation work beyond just splitting tasks?.
There's also a quiet cost to naive voting that the corpus flags: plain majority voting *throws away* the reasoning in every losing chain. Meta-reasoning approaches instead read across all the chains at once to harvest the distributed information, improving both accuracy and producing an auditable explanation Does voting discard useful reasoning from losing chains?. So 'voting at every level' might be the wrong frame — at finer levels you may want consensus-*aware* aggregation rather than blunt majority rule. And voting's reward signal can be recycled, not just consumed: Test-Time RL turns majority votes into a training reward on unlabeled data, bootstrapping the model because consensus answers tend to be correct Can models improve themselves using only majority voting?.
The deeper pattern across the collection is that decomposition itself is what makes per-level voting possible — and several papers argue decomposition deserves to be a first-class, separable structure. Splitting the decomposer from the solver improves accuracy, and notably the *planning* skill transfers across domains while the solving skill doesn't Does separating planning from execution improve reasoning accuracy?. LLM Programs go further, embedding models inside explicit algorithms that hand each call only its step-relevant context, turning reasoning into modular, debuggable sub-tasks Can algorithms control LLM reasoning better than LLMs alone?, and recursive subtask trees let a single model recurse through sub-problems while pruning its own working memory Can recursive subtask trees overcome context window limits?. Once a task is carved into clean, individually-checkable units like these, voting (or any verifier) has a surface to act on at every node.
One caution worth carrying away: the same verification logic applies to the *scorer*, not just the steps. Reward models reason better when they think before scoring Can reward models benefit from reasoning before scoring?, and multi-agent teams can even score and deactivate their own weakest members at inference time Can multi-agent teams automatically remove their weakest members?. So the richest version of 'voting at every level' isn't uniform majority rule everywhere — it's matching the *aggregation method* (majority vote, meta-reasoning, contribution scoring, sequential accumulation) to whether each level is independently verifiable or sequentially entangled.
Sources 10 notes
MAKER solves million-step tasks with zero errors by decomposing into minimal subtasks, applying voting at each step, and flagging correlated errors. Surprisingly, small non-reasoning models suffice when decomposition is extreme enough, inverting the standard approach to hard problems.
On structured tasks requiring sequential multi-step reasoning like graph connectivity, chain-of-thought achieves exponentially higher accuracy than parallel voting. The difference emerges because solutions genuinely require accumulating intermediate results sequentially, which short parallel chains cannot achieve.
Delegation requires matching tasks to agents across 11 dimensions: complexity, criticality, uncertainty, duration, cost, resource requirements, constraints, verifiability, reversibility, contextuality, and subjectivity. Verifiability is foundational—it determines whether outcomes can be evaluated at all.
Standard self-consistency voting selects the majority answer but discards intermediate reasoning from non-winning chains. Multi-chain reasoning instead meta-reasons over all chains simultaneously to extract distributed information, improving both task accuracy and producing coherent, auditable explanations.
Test-Time RL generates reward signals by majority voting across repeated samples, enabling policy improvement without ground-truth labels or trained reward models. This approach works surprisingly well because consensus answers tend to be correct, creating a bootstrapping loop where test-time compute enables training that improves the model.
Modular architectures with separate decomposer and solver models outperform monolithic LLMs, with decomposition ability transferring across domains while solving ability does not. The separation prevents planning-execution interference and produces more generalizable skills.
LLM Programs embed LLMs within explicit algorithms that manage control flow and state, presenting only step-specific context to each LLM call. This information hiding addresses capability and context window limits while treating complex reasoning as modular, debuggable sub-tasks.
The Thread Inference Model demonstrates that reasoning structured as recursive subtask trees with rule-based KV cache pruning sustains accurate reasoning beyond context limits, even when manipulating 90% of the cache. This enables single models to replace multi-agent systems by handling full recursive reasoning internally.
Three independent teams (RRM, RM-R1, DeepSeek-GRM) discovered that adding chain-of-thought reasoning before reward scoring enables adaptive test-time compute scaling for evaluation. Reasoning-based approaches raise the capability ceiling of reward models beyond what outcome-based evaluation achieves.
DyLAN's three-step importance scoring mechanism (propagation, aggregation, selection) quantifies individual agent contributions and automatically removes uninformative agents during inference, optimizing team composition without task-specific tuning.