Agentic Aggregation for Parallel Scaling of Long-Horizon Agentic Tasks
| Authors | Yoonsang Lee et al. |
| Year | 2026 |
| HF Upvotes | 14 |
| arXiv | 2604.11753 |
| Download | |
| HF Page | View on Hugging Face |
Abstract
We study parallel test-time scaling for long-horizon agentic tasks such as agentic search and deep research, where multiple rollouts are generated in parallel and aggregated into a final response. While such scaling has proven effective for chain-of-thought reasoning, agentic tasks pose unique challenges: trajectories are long, multi-turn, and tool-augmented, and outputs are often open-ended. Aggregating only final answers discards rich information from trajectories, while concatenating all trajectories exceeds the model's context window. To address this, we propose AggAgent, an aggregation agent that treats parallel trajectories as an environment. We equip it with lightweight tools to inspect candidate solutions and search across trajectories, enabling it to navigate and synthesize information on demand. Across six benchmarks and three model families (GLM-4.7, Qwen3.5, MiniMax-M2.5), AggAgent outperforms all existing aggregation methods-by up to 5.3% absolute on average and 10.3% on two deep research tasks-while adding minimal overhead, as the aggregation cost remains bounded by a single agentic rollout. Our findings establish agentic aggregation as an effective and cost-efficient approach to parallel test-time scaling.
Engineering Breakdown
Plain English
This paper addresses a real problem in scaling agentic AI systems: when you run multiple parallel rollouts of a long, tool-using agent (like one doing research or search), you can't just keep the final answer because you lose intermediate reasoning, and you can't concatenate everything because it explodes the context window. The authors propose AggAgent, a meta-agent that treats parallel trajectories as an explorable environment and uses lightweight tools to inspect and synthesize solutions across those trajectories. The core insight is that trajectory aggregation for agentic tasks requires active navigation and synthesis, not passive selection or concatenation, enabling more efficient use of parallel compute for long-horizon tasks.
Core Technical Contribution
The novelty here is reframing trajectory aggregation as an agentic problem itself—rather than engineering a fixed aggregation function, the authors equip a learned agent with tools to explore and reason over parallel trajectories as an interactive environment. This is fundamentally different from prior work on scaling via multiple rollouts, which either selected a single best trajectory or concatenated results (both suboptimal). The technical insight is that open-ended, multi-turn, tool-augmented tasks generate trajectories with rich internal structure—intermediate states, tool calls, reasoning—that should be actively synthesized rather than treated as atomic outputs. By making the aggregator itself an agent with search and inspection capabilities, the approach adapts to task-specific trajectory patterns without hand-engineered rules.
How It Works
The input is a set of K parallel rollouts from an agentic task (e.g., search or research), each containing a multi-turn trajectory of states, tool calls, and intermediate outputs. The AggAgent is initialized with access to these trajectories and a lightweight toolkit that lets it inspect specific checkpoints, compare solution branches, and search across trajectories. The agent operates in a loop: at each step, it can query individual trajectories (e.g., 'what tool did trajectory 3 use at step 5?'), compare outcomes, or synthesize a candidate solution by pulling insights from multiple trajectories. The agent's goal is to navigate this trajectory space and construct a final response that aggregates the best reasoning paths, avoiding both information loss (from picking one trajectory) and context explosion (from concatenating all). The architecture treats the trajectory database as an environment with observation and action spaces, allowing the agent to learn effective navigation patterns during training.
Production Impact
For teams building long-horizon agentic systems (research agents, complex planning, tool-augmented workflows), this directly addresses a scaling bottleneck: parallel compute becomes more useful because you're not bottlenecked by single-trajectory context limits or forced to discard intermediate reasoning. In practice, if you adopt this approach, your inference pipeline changes: instead of aggregating outputs at the end, you spawn multiple rollout workers, feed results to an AggAgent process, and wait for synthesis—this adds a sequential aggregation step that could increase latency, but should improve quality and sample efficiency. The compute trade-off is favorable if your downstream task (e.g., a user-facing research agent) benefits from deeper synthesis; less favorable if latency is critical. Integration complexity is moderate: you need to instrument your agentic task to expose trajectory checkpoints and tool calls, and train or prompt the aggregation agent on your domain, which requires labeled data of high-quality trajectory synthesis.
Limitations and When Not to Use This
The approach assumes trajectories are long and multi-step enough to justify the overhead of trajectory inspection—for short, single-turn tasks, this adds latency without benefit. It also assumes meaningful diversity across parallel rollouts; if your agent is deterministic or highly correlated, parallel trajectories won't provide enough signal for effective synthesis. The paper doesn't deeply address the cold-start problem: training the AggAgent requires examples of good trajectory synthesis, which is expensive to collect for novel agentic tasks. There's also an implicit assumption that trajectory structure is interpretable and comparable (i.e., that you can meaningfully extract and compare intermediate states), which may not hold for all task domains. Finally, the method scales with trajectory length and parallelism—very long trajectories or high K could still strain the aggregator's ability to navigate the space, leaving a question about scalability limits in practice.
Research Context
This builds directly on test-time scaling work (e.g., majority voting, tree search in reasoning) but extends it to the agentic regime where outputs are not atomic—prior work like Best-of-N selection or Chain-of-Thought aggregation didn't handle the complexity of multi-turn, tool-dependent trajectories. It connects to meta-reasoning and self-reflection literature (agents reasoning about their own behavior) and to hierarchical planning (the aggregator is a meta-level planner). The work also relates to recent progress in long-context reasoning and mixture-of-experts approaches, where multiple specialized paths are explored in parallel. This likely opens up new research directions in adaptive trajectory navigation, learned aggregation policies, and the scaling laws of agentic systems—e.g., how does aggregation quality scale with K and trajectory length?
:::tip Subscribe Get weekly breakdowns of papers like this in AI Letters - the newsletter for engineers building production AI systems. :::