Agentic Aggregation for Parallel Scaling of Long-Horizon Agentic Tasks

The paper introduces AggAgent, an aggregation agent that treats parallel agentic trajectories as an interactive environment with search tools to synthesize information on demand, thereby achieving superior performance and cost-efficiency in long-horizon tasks compared to existing aggregation methods.

The Gist

Imagine you are trying to solve a incredibly difficult, multi-step mystery, like finding the oldest mayor of a specific city in 1990 based on a list of skyscrapers. You have a team of brilliant detectives (AI agents), but they are prone to making mistakes, getting lost, or hallucinating facts.

The paper introduces a new way to solve these mysteries called AggAgent. Here is how it works, explained through simple analogies.

The Problem: The "Too Many Cooks" Dilemma

In the past, to get a better answer from an AI, researchers would just ask it to try the same task 8 times in parallel (like asking 8 detectives to investigate the same crime).

• The Old Way (Voting): You ask all 8 detectives for their final conclusion. If 5 say "Houston" and 3 say "New York," you just pick Houston. Problem: What if the 3 people who said "New York" were actually right, but they were in the minority? You lost the truth.
• The "Summary" Way: You ask each detective to write a 1-page summary of their investigation, then you read all 8 summaries. Problem: Summaries lose details. If a detective found a crucial clue on page 50 of their 100-page report, the summary might miss it.
• The "Read Everything" Way: You try to read all 8 detectives' full 100-page reports at once. Problem: It's too much information! Your brain (the AI's memory) gets overwhelmed, and it's too expensive to pay for all that reading time.

The Solution: The "Super-Detective Editor" (AggAgent)

The authors propose AggAgent. Instead of just voting or summarizing, they create a Super-Detective Editor.

Imagine you have a room with 8 open filing cabinets (the 8 different investigation reports). The Super-Detective Editor doesn't read every single page of every cabinet immediately. Instead, they have a special set of flashlights and search tools:

1. The "Solution Flashlight" (get_solution): First, the Editor quickly glances at the final conclusion of every detective to see what the general consensus is.
2. The "Keyword Search" (search_trajectory): If the detectives disagree (e.g., 5 say Houston, 3 say NYC), the Editor doesn't guess. They use a search tool to instantly jump to the specific pages in the reports where the detectives mention "mayor" or "1990."
3. The "Deep Dive" (get_segment): If the search tool finds a suspicious clue, the Editor pulls out just those specific pages to read the raw evidence (the actual search results the detectives found) to see if the detective interpreted them correctly.

Why This is a Game-Changer

The magic of AggAgent is that it acts like a smart librarian rather than a passive reader.

• It's "On-Demand": It doesn't read the whole book unless it has to. It only opens the specific pages where the clues are hidden. This keeps the cost low and the speed high.
• It's "Full Fidelity": It never summarizes or compresses the evidence. It looks at the raw data, so it never misses a tiny detail that a summary might have thrown away.
• It Synthesizes: If Detective A found a clue about the mayor in 1990, and Detective B found a clue about the city's population, the Editor combines these two separate facts into one perfect answer, even if no single detective had the full picture.

The Result

In the paper's experiments, this "Super-Detective Editor" consistently beat all other methods.

• It solved Deep Research tasks (like writing complex medical reports) much better than before because it could stitch together the best parts of different attempts.
• It was cheaper and faster than reading everything, because it only read what was necessary.

The Big Picture

Think of AggAgent as the ultimate Editor-in-Chief for a newsroom.

• Old Method: Ask 8 reporters to write a headline, then pick the most popular one.
• New Method (AggAgent): The Editor looks at all 8 reporters' notebooks. They spot the contradictions, jump to the specific interview notes that matter, verify the facts, and then write the perfect final story by combining the best parts of everyone's work.

This approach allows AI to tackle massive, complex tasks that were previously too confusing or expensive to solve, simply by being a smarter, more strategic aggregator of information.

Technical Summary

1. Problem Definition

The paper addresses the challenge of parallel test-time scaling for long-horizon agentic tasks (e.g., deep research, agentic search, software engineering). While scaling inference compute via parallel sampling (generating multiple independent trajectories) has proven effective for Chain-of-Thought (CoT) reasoning tasks like math and coding, it faces unique hurdles in agentic tasks:

• Trajectory Complexity: Agentic trajectories are multi-turn, span hundreds of steps, and involve interleaved tool calls and observations.
• Information Loss vs. Context Limits:
  • Aggregating only final answers (Solution Aggregation) discards rich intermediate reasoning and evidence.
  • Concatenating all trajectories exceeds the context window of current LLMs (often hundreds of thousands of tokens).
  • Summarizing trajectories (Summary Aggregation) is computationally expensive and results in irreversible information loss (lossy compression).
• The Core Question: How can we effectively aggregate multiple parallel agentic trajectories to synthesize a superior solution without incurring prohibitive costs or losing critical evidence?

2. Methodology: AggAgent

The authors propose AggAgent, a novel framework that treats the set of parallel trajectories as an interactive environment rather than a static text block. AggAgent is an "aggregation agent" that navigates these trajectories on-demand using lightweight, in-memory tools.

Key Components

• Agentic Workflow: Instead of feeding all data into the context, AggAgent interacts with the trajectories via a specific set of tools, keeping the context window bounded by a single rollout regardless of the number of parallel samples ($K$).
• Tool Suite:
  1. get_solution(traj_id): Retrieves the final answer from specific or all trajectories.
  2. search_trajectory(traj_id, query, role, k): Performs keyword searches within a specific trajectory, returning top-matching steps ranked by relevance (ROUGE-L). It can filter by role (e.g., only "tool" observations vs. "assistant" reasoning).
  3. get_segment(traj_id, start, end): Reads a contiguous range of steps to inspect raw tool outputs and surrounding context.
  4. finish(): Submits the final synthesized solution and reasoning.
• Coarse-to-Fine Strategy:
  1. Survey: AggAgent first inspects metadata and final solutions to identify consensus or disagreements.
  2. Investigate: It selectively dives into specific trajectories using search_trajectory to verify claims against tool observations.
  3. Deep Dive: If keyword searches are insufficient, it uses get_segment to read full context blocks.
  4. Synthesize: It constructs a final answer by cross-referencing evidence, resolving conflicts, and combining partial correct information from different trajectories.

Cost Efficiency

• Bounded Overhead: The aggregation cost is limited to a single agentic rollout. Unlike Summary Aggregation, which requires $K$ separate LLM calls to compress trajectories, AggAgent's cost is independent of $K$ (beyond the initial parallel rollouts).
• No External Latency: Tools operate entirely over an in-memory array of completed trajectories, avoiding the latency and API costs of external services like web search.

3. Key Contributions

1. Agentic Aggregation Paradigm: The paper introduces the concept of treating parallel trajectories as an interactive environment, enabling full-fidelity cross-trajectory reasoning without context window limitations.
2. Tool-Based Navigation: The design of lightweight, in-memory tools (search_trajectory, get_segment) allows the aggregator to inspect specific evidence dynamically, avoiding the information loss of summarization.
3. Pareto-Optimal Scaling: AggAgent achieves a superior trade-off between performance and cost/latency compared to existing baselines.
4. Empirical Validation: Extensive evaluation across three model families (GLM-4.7, Qwen3.5, MiniMax-M2.5) and six benchmarks demonstrates consistent superiority.

4. Experimental Results

The authors evaluated AggAgent on six benchmarks: BrowseComp, BrowseComp-Plus, HLE (Humanity's Last Exam), DeepSearchQA, Healthbench-Hard, and ResearchRubrics.

• Performance Gains:
  • AggAgent outperformed all baselines (Majority Voting, Best-of-N, Solution Aggregation, Summary Aggregation) across all models.
  • Average Improvement: Up to 5.3% absolute improvement over the strongest baseline (Solution Aggregation).
  • Deep Research Tasks: Up to 10.3% improvement on deep research benchmarks (e.g., Healthbench-Hard, ResearchRubrics), where trajectory synthesis is critical.
  • Surpassing Pass@8: In some cases, AggAgent's aggregated output outperformed the best single trajectory from 8 parallel runs (Pass@8), proving that synthesis creates value beyond simple selection.
• Cost and Latency:
  • AggAgent added only 5.7% overhead over the cost of running 8 parallel agents (compared to 41% for Summary Aggregation).
  • It achieved Pareto-optimal performance-efficiency trade-offs, consistently delivering higher performance at lower cost and latency than Summary Aggregation.
• Ablation Studies:
  • Synthesis vs. Selection: AggAgent (synthesis) significantly outperformed a variant that simply selected the "best" trajectory, especially in deep research tasks where no single trajectory is perfect.
  • Model Strength: Using a stronger model for the aggregator (e.g., MiniMax-M2.5 aggregating GLM-4.7 rollouts) further improved performance, suggesting an asymmetric allocation strategy is effective.

5. Significance and Impact

• Scalable Long-Horizon Reasoning: AggAgent provides a practical, training-free solution to scale agentic tasks that were previously limited by context window constraints or the high cost of summarization.
• Cost-Efficiency: It demonstrates that high-quality aggregation does not require massive computational overhead; a single "orchestrator" agent can effectively synthesize information from many parallel workers.
• Robustness to Hallucination: By verifying claims against raw tool observations (via search_trajectory and get_segment), AggAgent can identify and correct hallucinations or reasoning errors present in individual trajectories, even when the majority of trajectories are incorrect.
• Future Direction: The work establishes agentic aggregation as a principled paradigm for test-time scaling and opens avenues for training specialized aggregator agents to further optimize this process.

In summary, AggAgent solves the "context vs. fidelity" dilemma in parallel agentic scaling by enabling an agent to dynamically navigate and synthesize evidence from multiple parallel trajectories, achieving state-of-the-art performance with minimal additional cost.