Running many AI attempts in parallel beats thinking deeper — unless the task requires each step to build on the last.
Should agents use parallel or sequential scaling during test time?
This explores when an agent should spend its test-time compute by running many independent attempts in parallel (sampling, voting, search width) versus working through one longer chain step-by-step — and the corpus suggests the honest answer is that it depends on whether the task's solution has to be built up sequentially, plus a deeper point that the whole framing may be the wrong axis.
This explores when an agent should spend its test-time compute by running many independent attempts in parallel versus extending one chain step-by-step. The cleanest split the corpus offers: it depends on whether intermediate results genuinely have to accumulate. On structured, compositional problems — think tracing connectivity through a graph — sequential chain-of-thought has an *exponential* accuracy advantage over parallel voting, because the answer literally cannot be reached without carrying forward partial results that short parallel chains never build When does sequential reasoning beat parallel voting?. Where the task decomposes into independent guesses, parallel width wins on latency: sampling many trajectories at once sidesteps the serial wait of going deeper, and can do so without the variance blowup you'd expect Can reasoning systems scale faster by exploring parallel paths instead?.
But the more useful reframe is that 'parallel vs. sequential' isn't one knob — it's several different compute axes that scale on their own curves. There's internal scaling (training the model to reason autonomously) versus external scaling (search and verification bolted on at inference), and these complement rather than compete: internal builds the capability, external extracts more from it How do internal and external test-time scaling compare?. Separately, for agents specifically, *interaction* scaling — taking more steps in the environment to explore, backtrack, and replan — turns out to be orthogonal to reasoning depth, and it dominates on tasks where the agent can't see everything up front Does agent interaction time scale separately from reasoning depth?. Even search behaves like a scaling dimension: search budget follows the same diminishing-returns curve as reasoning tokens, so 'how many times do I look things up' becomes a compute dial you trade against 'how long do I think' How does test-time scaling work for individual research agents?, Does search budget scale like reasoning tokens for answer quality?.
The somewhat deflating result lurking underneath all of this: at the multi-agent level, roughly 80% of the performance variance comes from *how many tokens you spend*, not from clever coordination between agents How does test-time scaling work at the agent level?. So the parallel-vs-sequential question is partly a disguised budget question — and the real lever is allocation. Spending a uniform budget on every prompt wastes compute on easy problems and starves hard ones; adaptively matching spend to difficulty beats any fixed strategy How should we spend compute at inference time?. The right answer isn't 'always parallel' or 'always sequential' but 'route per task.'
Which points to the practical design pattern: don't pick one mode globally. Use sequential depth when results must compound, parallel width when attempts are independent and you care about latency, interaction steps when the environment is only partially observable, and size the model to the subtask — small models handle most repetitive agentic work at a fraction of the cost, with big models reserved for the hard parts Can small language models handle most agent tasks?. And if you want to actually know which mix is working, single-score 'did it succeed' benchmarks won't tell you — you need to measure trajectory quality, verification cost, and context efficiency to see where your compute is going Should agent evaluation measure more than task success?.
The thing you didn't know you wanted to know: the question quietly assumes parallel and sequential are rivals on a single dial. The corpus says they're different dials entirely — and that for multi-agent systems, the dial that matters most is just the total token budget, with everything else being how you choose to spend it.
Sources 10 notes
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.
GRAM demonstrates that recursive reasoning models should maintain and explore multiple latent trajectories in parallel, not only deepen single paths. Width-scaling avoids the serial latency penalty of depth while sampling the solution distribution more effectively on ambiguous problems.
Research shows test-time scaling methods split into internal (training models for autonomous reasoning) and external (inference-time search and verification). They complement rather than compete; internal builds capability while external extracts performance from existing capability.
Test-time interaction—increasing environment steps—enables exploration, backtracking, and replanning that per-step reasoning cannot achieve. Curriculum-based RL on rollout length produces SOTA web agents, showing interaction scaling dominates on tasks with partial observability.
Research shows that deep research agents exhibit test-time scaling laws where search steps scale similarly to reasoning tokens, and live search outperforms memorized retrieval on knowledge-intensive tasks. Data efficiency is extreme—78 curated demonstrations outperform 10K samples for agency.
Show all 10 sources
Agentic deep research shows monotonic-to-diminishing-returns curves for search iterations, matching reasoning token scaling. This creates a new inference-compute axis: models can trade off reasoning budget against search budget to optimize answer quality.
Research shows 80% of multi-agent performance variance comes from token budget, not coordination intelligence. LatentMAS and shared-KV-cache approaches offer ways to decouple performance gains from token costs.
Research shows that uniform inference budgets waste compute; allocation should vary by prompt. Test-time compute can substitute for training-time scaling on hard problems, but cannot overcome fundamental limitations set by the training regime.
SLMs handle the repetitive, well-defined language tasks that constitute most agent work at 10–30× lower cost than LLMs, making heterogeneous architectures (SLMs by default, LLMs selective) the economically rational design pattern.
One-shot task accuracy hides critical system behavior across trajectory quality, memory hygiene, context efficiency, and verification cost. Multi-dimensional measurement is harder to optimize but essential because identical success rates mask enormous differences in resource consumption and reliability.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Learning to Think: Information-Theoretic Reinforcement Fine-Tuning for LLMs
- Towards a Science of Scaling Agent Systems
- Does Thinking More always Help? Understanding Test-Time Scaling in Reasoning Models
- Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters
- RLAD: Training LLMs to Discover Abstractions for Solving Reasoning Problems
- ZebraLogic: On the Scaling Limits of LLMs for Logical Reasoning
- Artifacts as Memory Beyond the Agent Boundary
- A Survey on Test-Time Scaling in Large Language Models: What, How, Where, and How Well?