Letting an AI agent search longer — without retraining — improves research answers the same way deeper reasoning does.
Does test-time compute scaling work for agentic deep research tasks?
This explores whether throwing more inference-time compute at a research agent — letting it search and reason longer rather than retraining or enlarging the model — actually buys better answers, and where the gains taper off.
This explores whether throwing more inference-time compute at a research agent — letting it search and reason longer rather than swapping in a bigger model — actually buys better answers. The corpus answers yes, and with an interesting twist: the thing that scales isn't just reasoning, it's *search itself*. Several notes converge on the finding that an agent's search budget follows the same scaling curve as its reasoning tokens — more search steps improve answer quality along the same monotonic-then-diminishing path that more chain-of-thought does Does search budget scale like reasoning tokens for answer quality? Do search steps follow the same scaling rules as reasoning tokens?. The reframing is the payoff: search stops being plumbing and becomes a *compute axis* you can dial, trading reasoning budget against retrieval budget to optimize the result How does test-time scaling work for individual research agents?.
But 'just spend more tokens' comes with sharp caveats. At the multi-agent level, roughly 80% of performance variance turns out to be a function of token spend rather than any clever coordination between agents — which is freeing (you know what knob to turn) and sobering (much of the apparent intelligence is just budget) How does test-time scaling work at the agent level?. And spending only helps if the model was trained to use it: non-reasoning models don't catch up to reasoning models no matter how much inference compute you pour in, because training instills a protocol that makes the extra tokens productive in the first place Can non-reasoning models catch up with more compute?. So test-time scaling extracts capability the model already has — it doesn't manufacture it. That's the internal-vs-external split worth knowing: internal scaling (training for autonomous reasoning) builds the capability, external scaling (inference-time search and verification) cashes it out, and the two complement rather than substitute How do internal and external test-time scaling compare?.
The deeper trade is that inference compute and model size are not separate resources. On hard prompts, a smaller model given more thinking time matches a larger one — compute spent at inference can stand in for compute spent on parameters Can inference compute replace scaling up model size?. The catch is that uniform spending is wasteful: dumping a fixed budget on every query overpays for easy questions and starves the hard ones, so adaptive per-prompt allocation beats flat budgets How should we spend compute at inference time?. For a research agent fielding a mix of trivial and gnarly sub-questions, that's the real lever — not 'more,' but 'more where it counts.'
What the reader might not expect: scaling doesn't have to mean *deeper*. You can scale *wider* by sampling parallel trajectories instead of one long serial chain, sidestepping the latency tax of depth Can reasoning systems scale faster by exploring parallel paths instead?. And there's a striking inversion at the extreme — decompose a task into enough tiny verified subtasks with voting at each step, and small non-reasoning models execute million-step jobs error-free, no expensive reasoning model required Can extreme task decomposition enable reliable execution at million-step scale?. Two routes to reliability that don't look like 'bigger budget' at all.
So: test-time scaling genuinely works for agentic deep research, but the honest version is layered — search scales like reasoning, most multi-agent gains are just spend, the spend only pays off on models trained to reason, and the smartest agents allocate adaptively, sometimes going wide or decomposing rather than simply spending more. If you want the structural picture of how all this fits together, the internal/external taxonomy is the doorway How do internal and external test-time scaling compare?.
Sources 10 notes
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.
Deep research agents improve with more search steps in a pattern mirroring the reasoning-token relationship, with both exhibiting diminishing returns. This reveals a new inference-compute axis beyond model capability alone.
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.
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.
Reasoning models persistently outperform non-reasoning models regardless of inference budget because training instills a reasoning protocol that makes additional tokens productive. The gap is fundamentally about deployment mechanisms and training structure, not raw capability.
Show all 10 sources
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.
Snell et al. (2024) showed that inference-time compute trades off against model parameter scaling, especially on difficult prompts. This reveals pretraining and inference compute are not independent resources.
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.
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.
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.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- When More Thinking Hurts: Overthinking in LLM Test-Time Compute Scaling
- ZebraLogic: On the Scaling Limits of LLMs for Logical Reasoning
- Reasoning Models Can Be Effective Without Thinking
- Does Thinking More always Help? Understanding Test-Time Scaling in Reasoning Models
- Learning to Think: Information-Theoretic Reinforcement Fine-Tuning for LLMs
- Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters
- From Web Search towards Agentic Deep Research: Incentivizing Search with Reasoning Agents
- Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking Token Budgets