Agentic Aggregation for Parallel Scaling of Long-Horizon Agentic Tasks

Yoonsang Lee; Howard Yen; Xi Ye; Danqi Chen

cs.CLApr 13, 2026

Agentic Aggregation for Parallel Scaling of Long-Horizon Agentic Tasks

Authors: Yoonsang Lee, Howard Yen, Xi Ye, Danqi Chen

Organizations: Princeton Language and Intelligence, Princeton University

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.

Figures & tables

Figure 1: AggAgent consistently outperforms existing aggregation methods. We measure the average performance across six long-horizon agentic benchmarks (Section 4 ) against the number of parallel trajectories. The same model as the rollout agent serves as the aggregator.

Figure 2: Overview of aggregation methods for parallel scaling. (Top) An agent produces $K=3$ independent rollouts on a long-horizon task. (Bottom) Solution Aggregation feeds only final solutions to an LLM, discarding intermediate reasoning. Summary Aggregation compresses each trajectory into a lossy summary. AggAgent (ours) navigates trajectories via tools in an agentic manner, enabling full-fidelity cross-trajectory reasoning at low cost.

Criterion	MV	WMV	BoN	FewTool	SolAgg	SummAgg	AggAgent (Ours)
Task-agnostic	✗	✗	✓	✓	✓	✓	✓
Non-heuristic	✗	✗	✗	✗	✓	✓	✓
Trajectory Info.	✗	✗	✗	✗	✗	✓	✓
Full Fidelity	✗	✗	✗	✗	✗	✗	✓
Aggregation Cost	Zero	Zero	Zero	Zero	Low	High	Low

Table 1: Comparison of aggregation methods . Task-agnostic : not restricted to single short answers, applicable to multi-answer and long-form tasks. Non-heuristic : does not rely on shallow signals such as frequency or confidence. Trajectory Info. : reasons over full trajectories beyond final solutions. Full Fidelity : accesses trajectories without compression or information loss. Aggregation Cost : additional inference cost beyond the rollouts.

	\Block 2-1 Task	\Block 2-1 Pass@1	Heuristic Aggregation@8				LLM-based Aggregation@8
			MV	WMV	BoN	FewTool	SolAgg	SummAgg	AggAgent
\Block [fill=red!8]7-1 GLM-4.7-Flash	BrowseComp	27.42	32.67	50.67	51.33	41.33	53.33	55.33	56.00
	BrowseComp-Plus	49.08	59.33	68.67	68.67	62.00	70.67	70.67	71.33
	HLE	25.00	26.45	27.74	30.97	27.10	32.90	34.84	37.42
	DeepSearchQA	32.42	–	–	35.33	33.33	46.00	47.33	49.33
	Healthbench-Hard	8.67	–	–	9.91	8.90	15.72	7.35	27.99

Table 2: AggAgent performs the best across all settings. We evaluate on six long-horizon tasks using three model families, each generating

K{=}8

independent rollouts. For LLM-based aggregation methods, the same model is used for both rollout and aggregation. Best metric per row is bolded. – denotes that voting-based methods are not applicable, and we use Pass@1 instead to calculate the average score.

Figure 3: AggAgent achieves a Pareto-optimal performance–efficiency tradeoff . We compare aggregation methods at

K\in\{2,4,8\}

parallel samples, averaging performance across six benchmarks, with the same model serving as both rollout agent and aggregator. For each model, the top chart plots average cost (USD per query) vs. performance and the bottom chart plots average latency (seconds per query) vs. performance.

Figure 4: Employing a stronger aggregator improves performance on LLM-based aggregation methods . In all cases, GLM-4.7-Flash serves as the rollout agent; blue bars replace the aggregator with the stronger MiniMax-M2.5, while red bars use GLM-4.7-Flash for both roles. Yellow hatched bars denote Pass@ $K$ . All methods are evaluated at $K{=}8$ .

Figure 5: Ablation of solution synthesis vs. best-trajectory selection . AggAgent synthesizes a new solution from the collected trajectories; the selection variant selects the single best trajectory directly. Color indicates model (red: GLM-4.7-Flash, green: Qwen3.5-122B, blue: MiniMax-M2.5); line style and marker indicate method (solid + circle: AggAgent, dashed + diamond: selection variant).

Table 3: Tool design ablations. Scores are averaged across six benchmarks at

K{=}8

and the same model is used for both rollout generation and aggregation. Table 3(a) compares retrieval backends for search_trajectory: ROUGE-L, BM25, and Qwen3-Embedding-8B; bold indicates the best retrieval backend in each row. Table 3(b) compares the default full-trajectory setting (Full) with a variant that restricts access to internal thinking traces (No Think.); red subscripts show the score change relative to Full.

Figure 6: Average number of tool calls per query by AggAgent. Numbers above each bar indicate the average total tool calls per query. search_trajectory dominates tool usage, while get_solution and finish are each called approximately once per query. get_segment is used more selectively, reflecting a coarse-to-fine strategy where AggAgent commits to full-content reads only when keyword-level search is insufficient.

Appendix figures & tables17 assets

Supplementary material from the paper’s appendix.

Appendix

Language Models (per 1M tokens)
	Input	Output
GLM-4.7-Flash	$0.07	$0.40
Qwen-3.5-122B	$0.26	$2.08
MiniMax-M2.5	$0.30	$1.20
Tool Calls (per 1K queries)
search	$0.50

Appendix

Table 4: Pricing used for cost calculation.

	Task	# Inst.	# Turns	Tokens (K)	Output (K)	# Tool Calls	Uniq. URLs
\Block [fill=red!8]6-1 GLM-4.7-Flash	BrowseComp	150	$71.4_{0.9}$	$64.8_{1.0}$	$0.64_{0.05}$	$70.4_{0.9}\ (59.0/11.4)$	$324.6_{9.4}$
	BrowseComp-Plus	150	$26.0_{0.8}$	$72.0_{1.8}$	$0.53_{0.01}$	$25.1_{0.8}\ (23.1/2.0)$	$50.1_{0.7}$
	HLE	155	$34.4_{1.7}$	$40.9_{2.2}$	$1.39_{0.12}$	$31.9_{1.5}\ (22.8/9.1)$	$86.8_{5.1}$
	DeepSearchQA	150	$53.4_{2.4}$	$48.3_{1.5}$	$0.71_{0.09}$	$52.6_{2.4}\ (37.9/14.7)$	$126.8_{3.9}$
	Healthbench-Hard	100	$17.8_{1.6}$	$27.0_{2.5}$	$1.74_{0.07}$	$16.9_{1.6}\ (7.9/9.0)$	$52.5_{6.1}$
	ResearchRubrics	101	$34.0_{1.8}$	$48.2_{2.1}$	$4.23_{0.11}$	$33.1_{1.8}\ (15.9/17.2)$	$121.4_{6.7}$

Appendix

Table 5: Trajectory statistics of base rollouts (8 per problem) across three models and six benchmarks. # Inst. : number of evaluation instances. # Turns : number of agent turns per trajectory. Tokens (K) : total input+output tokens in thousands. Output (K) : output tokens in thousands. # Tool Calls : total tool calls, broken down into search and visit calls (shown in parentheses; get_document is used instead of visit for BrowseComp-Plus). Uniq. URLs : number of unique URLs visited. All values are averaged over problems and rollouts, and subscripts denote standard deviation across rollout sets.

	SolAgg	SummAgg	RAG (ROUGE-L)	RAG (BM25)	RAG (Qwen3)	AggAgent
GLM-4.7-Flash	42.58	41.21	44.10	44.45	43.66	47.90
Qwen3.5-122B	52.78	51.69	51.27	51.91	52.07	55.83
MiniMax-M2.5	54.90	53.88	56.32	55.70	55.24	57.31

Appendix

Table 6: Trajectory-RAG baseline. Scores are averaged across six benchmarks at

K{=}8

, with the same model used for both rollout generation and aggregation. RAG variants index trajectory chunks, retrieve evidence with ROUGE-L, BM25, or Qwen3-Embedding-8B, and feed the retrieved chunks plus final solution candidates to a non-agentic LLM aggregator.

$\mathbf{K}$	Pass	Heuristic Aggregation				LLM-based Aggregation
$\mathbf{K}$	Pass	MV	WMV	BoN	FewTool	SolAgg	SummAgg	AggAgent
1	46.50	-	-	-	-	-	-	-
2	56.07	46.31	53.45	53.43	53.43	55.11	56.00	56.00
4	63.90	51.85	58.40	58.60	58.60	59.78	60.44	61.33
8	70.67	54.00	58.67	62.67	55.33	65.33	66.67	68.00

Appendix

Table 7: Combining sequential and parallel scaling. Results are on BrowseComp using Qwen3.5-122B with a simple context management policy for base rollouts. Best aggregation result per row is bolded.

Dataset	$N$	Retrieval	Evidence Interpretation	Conflict Resolution	Synthesis
BrowseComp	3	0.0%	66.7%	33.3%	0.0%
BrowseComp-Plus	2	0.0%	0.0%	0.0%	100.0%
HLE	19	10.5%	68.4%	10.5%	10.5%
DeepSearchQA	45	11.1%	57.7%	11.5%	19.2%

Appendix

Table 8: Failure mode analysis. We manually annotate MiniMax-M2.5 cases where Pass@

8

succeeds but AggAgent fails.

N

denotes the number of annotated failure cases.

Figure 7: Qualitative examples illustrating four key behaviours of AggAgent.

Task	$\mathbf{K}$	Pass	Heuristic Aggregation				LLM-based Aggregation
Task	$\mathbf{K}$	Pass	MV	WMV	BoN	FewTool	SolAgg	SummAgg	AggAgent
BrowseComp	1	$27.42_{2.17}$	-	-	-	-	-	-	-
	2	$37.86_{2.63}$	$27.26_{2.36}$	$35.79_{3.03}$	$35.60_{3.04}$	$33.24_{2.47}$	$35.78_{1.13}$	$34.89_{2.45}$	$\mathbf{37.78}_{1.37}$
	4	$49.21_{2.04}$	$30.83_{1.82}$	$43.87_{2.41}$	$44.06_{2.64}$	$38.84_{1.93}$	$45.33_{0.0}$	$\mathbf{46.22}_{0.83}$	$45.78_{1.13}$
	8	$58.67$	$32.67$	$50.67$	$51.33$	$41.33$	$53.33$	$55.33$	$\mathbf{56.00}$
BrowseComp-Plus	1	$49.08_{3.09}$	-	-	-	-	-	-	-

Appendix

Table 9: Performance comparison across aggregation strategies with GLM-4.7-Flash with varying

K\in\{2,4,8\}

. The same model is used for both rollout and aggregation. Bold indicates the best-performing method per row (excluding Pass). Subscripts report standard deviation across runs. ‘-’ denotes not applicable.

Task	$\mathbf{K}$	Pass	Heuristic Aggregation				LLM-based Aggregation
Task	$\mathbf{K}$	Pass	MV	WMV	BoN	FewTool	SolAgg	SummAgg	AggAgent
BrowseComp	1	$40.25_{3.26}$	-	-	-	-	-	-	-
	2	$50.38_{2.66}$	$40.74_{2.95}$	$47.79_{2.82}$	$48.05_{2.98}$	$46.21_{2.82}$	$48.44_{1.00}$	$\mathbf{49.33}_{2.88}$	$48.89_{1.13}$
	4	$59.53_{1.84}$	$45.54_{2.13}$	$54.30_{2.62}$	$54.83_{2.38}$	$51.42_{2.22}$	$55.78_{0.83}$	$56.00_{0.94}$	$\mathbf{56.22}_{1.60}$
	8	$67.33$	$47.33$	$60.00$	$58.67$	$56.00$	$61.33$	$62.00$	$\mathbf{62.67}$
BrowseComp-Plus	1	$58.67_{2.13}$	-	-	-	-	-	-	-

Appendix

Table 10: Performance comparison across aggregation strategies with Qwen3.5-122B. The table is formatted the same as Table 9 .

Task	$\mathbf{K}$	Pass	Heuristic Aggregation				LLM-based Aggregation
Task	$\mathbf{K}$	Pass	MV	WMV	BoN	FewTool	SolAgg	SummAgg	AggAgent
BrowseComp	1	$50.17_{3.35}$	-	-	-	-	-	-	-
	2	$60.86_{2.32}$	$50.40_{2.15}$	$59.40_{2.36}$	$59.36_{2.34}$	$57.38_{2.47}$	$60.00_{1.63}$	$59.78_{1.13}$	$\mathbf{60.22}_{1.13}$
	4	$68.64_{1.69}$	$56.58_{2.19}$	$64.73_{1.88}$	$66.06_{2.01}$	$62.63_{1.64}$	$64.44_{0.63}$	$66.67_{0.54}$	$\mathbf{67.33}_{0.0}$
	8	$73.33$	$60.67$	$66.67$	$70.67$	$67.33$	$70.67$	$70.00$	$\mathbf{71.33}$
BrowseComp-Plus	1	$64.17_{1.28}$	-	-	-	-	-	-	-

Appendix

Table 11: Performance comparison across aggregation strategies with MiniMax-M2.5. The table is formatted the same as Table 9 .

Task	$\mathbf{K}$	Rollout Cost ( $c_{r}$ )	Tool Call Cost ( $c_{t}$ )	Aggregation Cost ( $c_{a}$ )			Rollout Latency ( $t_{r}$ )	Aggregation Latency ( $t_{a}$ )
Task	$\mathbf{K}$			SolAgg	SummAgg	AggAgent		SolAgg	SummAgg	AggAgent
BrowseComp	1	.0086	.0390	-	-	-	185.10	-	-	-
	2	.0171	.0780	.0025	.0143	.0044	211.82	33.97	77.72	22.67
	4	.0343	.1560	.0021	.0261	.0048	233.74	21.38	107.27	38.51
	8	.0685	.3119	.0019	.0506	.0047	261.41	18.69	139.42	31.65
BrowseComp-Plus	1	.0067	0	-	-	-	457.47	-	-	-

Appendix

Table 12: Cost and latency breakdown with GLM-4.7-Flash. All costs are in USD per query, and all latencies are in seconds per query. ‘-’ denotes not applicable at

K\!=\!1

. BrowseComp-Plus incurs no tool cost.

Task	$\mathbf{K}$	Rollout Cost ( $c_{r}$ )	Tool Call Cost ( $c_{t}$ )	Aggregation Cost ( $c_{a}$ )			Rollout Latency ( $t_{r}$ )	Aggregation Latency ( $t_{a}$ )
Task	$\mathbf{K}$			SolAgg	SummAgg	AggAgent		SolAgg	SummAgg	AggAgent
BrowseComp	1	.0409	.0315	-	-	-	182.79	-	-	-
	2	.0817	.0629	.0102	.0565	.0213	224.26	21.96	53.60	39.07
	4	.1634	.1258	.0103	.1026	.0309	242.48	21.31	69.14	41.04
	8	.3268	.2517	.0103	.1952	.0209	305.38	20.93	91.82	36.25
BrowseComp-Plus	1	.0265	0	-	-	-	564.68	-	-	-

Appendix

Table 13: Cost and latency breakdown with Qwen3.5-122B. The table is formatted the same as Table 12 .

Task	$\mathbf{K}$	Rollout Cost ( $c_{r}$ )	Tool Call Cost ( $c_{t}$ )	Aggregation Cost ( $c_{a}$ )			Rollout Latency ( $t_{r}$ )	Aggregation Latency ( $t_{a}$ )
Task	$\mathbf{K}$			SolAgg	SummAgg	AggAgent		SolAgg	SummAgg	AggAgent
BrowseComp	1	.0321	.0301	-	-	-	209.34	-	-	-
	2	.0642	.0602	.0055	.0389	.0122	259.73	267.45	300.34	294.52
	4	.1285	.1204	.0049	.0715	.0120	292.90	300.42	347.88	319.73
	8	.2569	.2409	.0049	.1357	.0118	314.26	323.33	480.36	352.57
BrowseComp-Plus	1	.0298	0	-	-	-	392.76	-	-	-

Appendix

Table 14: Cost and latency breakdown with MiniMax-M2.5. The table is formatted the same as Table 12 .

Task	$\mathbf{K}$	Pass	GLM-4.7-Flash			MiniMax-M2.5
Task	$\mathbf{K}$	Pass	SolAgg	SummAgg	AggAgent	SolAgg	SummAgg	AggAgent
BrowseComp	1	$27.42$	-	-	-	-	-	-
	2	$37.86$	$35.78$	$34.89$	$37.78$	$36.22$	$37.11$	39.11
	4	$49.21$	$45.33$	$46.22$	$45.78$	$46.22$	$44.44$	46.44
	8	$58.67$	$53.33$	$55.33$	56.00	$51.33$	$55.33$	$55.33$
BrowseComp-Plus	1	$49.08$	-	-	-	-	-	-

Appendix

Table 15: Performance of LLM-based aggregation strategies on GLM-4.7-Flash as the base rollout model, comparing GLM (same model) and MiniMax (stronger model) as the LLM aggregator, across varying

K

. Bold indicates the best-performing method per row (excluding Pass). Results show that using a stronger aggregator leads to better performance. ‘-’ denotes not applicable at

K\!=\!1

Figure 8: Performance-efficiency tradeoff of aggregation methods across six benchmarks at varying numbers of parallel samples

K=\{2,4,8\}

using GLM-4.7-Flash as both the rollout agent and the aggregator. For each group of three benchmarks, the first row shows performance vs. cost (USD per query) and the second row shows performance vs. latency (seconds per query). AggAgent consistently achieves higher performance at comparable or lower cost and latency than existing aggregation strategies.

Figure 9: Performance-efficiency trade-off of aggregation methods using Qwen3.5-122B as both the rollout agent and the aggregator. The figure is formatted the same as Figure 8 .

Figure 10: Performance-efficiency trade-off of aggregation methods using MiniMax-M2.5 as both the rollout agent and the aggregator. The figure is formatted the same as Figure 8 .

Figure 11: Confidence calibration across all six benchmarks. Each row is a benchmark and each column is a model. For binary-correctness (agentic search) benchmarks, box plots show self-reported confidence by outcome ( W rong vs. C orrect). For continuous-score (deep research) benchmarks, scatter plots show confidence vs. rubric score with Pearson

r

. Models are well-calibrated on BrowseComp-Plus and BrowseComp, moderately calibrated on HLE and DeepSearchQA, but poorly calibrated on Healthbench-Hard and ResearchRubrics (

r\approx 0

Explore similar work

Apr 16, 2026

Scaling Test-Time Compute for Agentic Coding

Test-time scaling has become a powerful way to improve large language models. However, existing methods are best suited to short, bounded outputs that can be directly compared, ranked or refined. Long-horizon coding agents violate this premise: each attempt produces an extended trajectory of actions, observations, errors, and partial progress taken by the agent. In this setting, the main challenge is no longer generating more attempts, but representing prior experience in a form that can be effectively selected from and reused. We propose a test-time scaling framework for agentic coding based on compact representations of rollout trajectories. Our framework converts each rollout into a structured summary that preserves its salient hypotheses, progress, and failure modes while discarding low-signal trace details. This representation enables two complementary forms of inference-time scaling. For parallel scaling, we introduce Recursive Tournament Voting (RTV), which recursively narrows a population of rollout summaries through small-group comparisons. For sequential scaling, we adapt Parallel-Distill-Refine (PDR) to the agentic setting by conditioning new rollouts on summaries distilled from prior attempts. Our method consistently improves the performance of frontier coding agents across SWE-Bench Verified and Terminal-Bench v2.0. For example, by using our method Claude-4.5-Opus improves from 70.9% to 77.6% on SWE-Bench Verified (mini-SWE-agent) and 46.9% to 59.1% on Terminal-Bench v2.0 (Terminus 1). Our results suggest that test-time scaling for long-horizon agents is fundamentally a problem of representation, selection, and reuse.

Joongwon Kim, Wannan Yang, Kelvin Niu +13

1Meta Superintelligence Labs · University of Washington · 3New York University +4

AI Coding Agents Test-Time Scaling Long-Horizon LLM Agents

Ask PDF

Jun 15, 2026

Beyond Parallel Sampling: Diverse Query Initialization for Agentic Search

Test-time scaling for agentic search typically increases depth (i.e., more turns and tokens per trajectory) or breadth (i.e., more parallel rollouts). Here we focus on breadth scaling, showing that standard parallel sampling yields diminishing returns, tracing this to query redundancy at the first turn. When models issue similar first queries across rollouts, the threads retrieve overlapping evidence, and subsequent turns are conditioned on this shared retrieval. We address this limitation with DivInit, a training-free intervention at the first turn. Rather than sampling k independent first queries, DivInit draws n candidates from a single call, picks k < n diverse seeds, and runs them as parallel trajectories. Across five open-weight models and eight benchmarks, DivInit consistently improves over standard parallel sampling, with average gains of five to seven points on multi-hop QA at matched compute. Code available at https://github.com/cxcscmu/diverse-query-initialization

Sidhaarth Murali, João Coelho, Jingjie Ning +3

Carnegie Mellon University, United States · Instituto Superior Técnico and INESC-ID, University of Lisbon, Portugal · NOVA LINCS, NOVA School of Science and Technology, Portugal

Agentic Search Test-Time Scaling

Ask PDF

Feb 26, 2026

Search More, Think Less: Rethinking Long-Horizon Agentic Search for Efficiency and Generalization

Recent deep research agents primarily improve performance by scaling reasoning depth, but this leads to high inference cost and latency in search-intensive scenarios. Moreover, generalization across heterogeneous research settings remains challenging. In this work, we propose Search More, Think Less (SMTL), a framework for long-horizon agentic search that targets both efficiency and generalization. SMTL replaces sequential reasoning with parallel evidence acquisition, enabling efficient context management under constrained context budgets. To support generalization across task types, we further introduce a unified data synthesis pipeline that constructs search tasks spanning both deterministic question answering and open-ended research scenarios with task appropriate evaluation metrics. We train an end-to-end agent using supervised fine-tuning and reinforcement learning, achieving strong and often state of the art performance across benchmarks including BrowseComp (48.6%), GAIA (75.7%), Xbench (82.0%), and DeepResearch Bench (45.9%). Compared to Mirothinker-v1.0, SMTL with maximum 100 interaction steps reduces the average number of reasoning steps on BrowseComp by 70.7%, while improving accuracy.

Qianben Chen, Tianrui Qin, King Zhu +21

Agentic Search Long-Horizon LLM Agents Autonomous Research Agents LLM Agent Training Long-Horizon Agent Evaluation

Ask PDF