AggAgent: Agentic Aggregation Framework

• AggAgent is a framework of agentic aggregation that actively coordinates multi-step agent outputs using lightweight tools and policy-aware supervision.
• It integrates language-model reasoning, distributed aggregative optimization, and supervisory orchestration to enable scalable, efficient decision-making under strict constraints.
• Empirical benchmarks show AggAgent delivers notable performance gains and cost reductions, validating its design for long-horizon tasks and real-world operational systems.

AggAgent denotes a family of frameworks and coordination architectures centered on agentic aggregation, with significant implementations in (1) language-model-based parallel aggregation for long-horizon reasoning (Lee et al., 13 Apr 2026), (2) distributed aggregative optimization in multi-agent networks (Liu et al., 30 Mar 2025), and (3) supervisory agentic orchestration within real-world operational systems such as electric bus fleet management (Manzolli et al., 24 Jun 2026). The unifying principle is the replacement of passive aggregation—such as final-answer voting or static averaging—by an agentic process that actively interacts with distributed, multi-step agent outputs or local decision policies, leveraging lightweight tooling, momentum, or policy-aware supervision to maximize task-level or network-level objectives subject to nontrivial constraints.

1. Formal Definitions and General Problem Settings

In the context of long-horizon agentic tasks, AggAgent operates over a query space $q \in \mathcal Q$, where a single agent $A$ interacting with an external environment produces a trajectory

$$T = \bigl(q,\, r_1, a_1, o_1,\, r_2, a_2, o_2,\, \dots,\, r_m, a_m, o_m,\, y\bigr),$$

with $r_j$ as internal reasoning, $a_j$ as tool-bound actions, $o_j$ as observations, and $y$ as the final output. For parallel scaling, $K$ independent trajectories $\mathcal T = \{T_1, \dots, T_K\}$ are produced. The aggregation objective is to synthesize $\hat y = f(q, \mathcal T)$ maximizing expected task quality $A$0, under strict context window and cost constraints (Lee et al., 13 Apr 2026).

In distributed aggregative optimization, each node $A$1 controls $A$2 with global objective

$A$3

where $A$4 is an aggregator function, under a connected communication graph (Liu et al., 30 Mar 2025). In operational orchestrations (e.g., fleet charging), a supervisory AggAgent layer coordinates multiple agents, each representing a subsystem or decision facet, over combinatorial and numeric states (Manzolli et al., 24 Jun 2026).

2. Architectural Constructs and Agentic Decision Flows

LLM Aggregation

AggAgent treats the collection $A$5 of trajectories as an interactive environment, possessing a state space $A$6 (trajectory metadata, tool output cache) and action space $A$7get_solution, search_trajectory, get_segment, finish$A$8. A decision loop enables the aggregator to selectively inspect, search, and cross-validate trajectory evidence, terminating when sufficient support for a candidate solution is deemed verified by the LLM-driven reasoning process. The core algorithmic structure guarantees that no more than $A$9 tokens are ever loaded in-context, maintaining strict adherence to context window constraints (Lee et al., 13 Apr 2026).

Distributed Optimization

In the distributed setting, AggAgent is instantiated algorithmically at each node as a pair of state trackers:

• Aggregator track $$T = \bigl(q,\, r_1, a_1, o_1,\, r_2, a_2, o_2,\, \dots,\, r_m, a_m, o_m,\, y\bigr),$$0, averaged via neighbor mixing, and
• Gradient track $$T = \bigl(q,\, r_1, a_1, o_1,\, r_2, a_2, o_2,\, \dots,\, r_m, a_m, o_m,\, y\bigr),$$1.

Heavy-ball (DAGT-HB) and Nesterov (DAGT-NES) variants update $$T = \bigl(q,\, r_1, a_1, o_1,\, r_2, a_2, o_2,\, \dots,\, r_m, a_m, o_m,\, y\bigr),$$2 with local momentum and aggregator-tracked gradients, yielding accelerated convergence while maintaining consensus and aggregation fidelity. The pseudocode updates (see Section 2, (Liu et al., 30 Mar 2025)) reinforce network-wide synchrony and enable robust, scalable optimization.

Agentic Supervisory Orchestration

In electric fleet operations, AggAgent is realized as a supervisory layer comprising three agents—Trigger Agent (disturbance detection), Pricing Agent (tariff adaptation), and Evaluator Agent (schedule acceptance)—that modulate an underlying scheduling MIP. All communication is restricted to structured, schema-constrained outputs (e.g., JSON, numeric vectors) to ensure auditability and minimize ambiguity (Manzolli et al., 24 Jun 2026).

3. Tools, Mechanisms, and On-Demand Inspection

The language-model instantiation of AggAgent employs a toolkit for efficient, targeted extraction of evidentiary segments from trajectories:

• $$T = \bigl(q,\, r_1, a_1, o_1,\, r_2, a_2, o_2,\, \dots,\, r_m, a_m, o_m,\, y\bigr),$$3: retrieves final outputs $$T = \bigl(q,\, r_1, a_1, o_1,\, r_2, a_2, o_2,\, \dots,\, r_m, a_m, o_m,\, y\bigr),$$4 for all $$T = \bigl(q,\, r_1, a_1, o_1,\, r_2, a_2, o_2,\, \dots,\, r_m, a_m, o_m,\, y\bigr),$$5,
• $$T = \bigl(q,\, r_1, a_1, o_1,\, r_2, a_2, o_2,\, \dots,\, r_m, a_m, o_m,\, y\bigr),$$6: ROUGE-L–ranked keyword search over tool or assistant steps,
• $$T = \bigl(q,\, r_1, a_1, o_1,\, r_2, a_2, o_2,\, \dots,\, r_m, a_m, o_m,\, y\bigr),$$7: indexed reading of contiguous reasoning+tool-output steps,
• $$T = \bigl(q,\, r_1, a_1, o_1,\, r_2, a_2, o_2,\, \dots,\, r_m, a_m, o_m,\, y\bigr),$$8: termination with XML-wrapped summary.

Such tools provide O(1) LLM calls, sublinear average-case lookups through indexed caching, and on-demand precision targeting only for high-disagreement or low-support candidate answers (Lee et al., 13 Apr 2026).

In the distributed optimization AggAgent, the “tools” are mathematical trackers (neighbor mixing, gradient tracking) and algorithmic momentum, executed at node-level without centralized oversight (Liu et al., 30 Mar 2025).

In the fleet scenario, tools are agentic modules—Trigger, Pricing, Evaluator—each encoded to manipulate only the relevant numeric or categorical summaries, thereby maintaining transparency and governability (Manzolli et al., 24 Jun 2026).

4. Complexity, Scalability, and Cost Analysis

For trajectory aggregation, AggAgent achieves:

• Cost: Bounded by a single agentic loop with LLM-token budget $$T = \bigl(q,\, r_1, a_1, o_1,\, r_2, a_2, o_2,\, \dots,\, r_m, a_m, o_m,\, y\bigr),$$9, independent of $r_j$0 (number of generated trajectories). Tool calls are in-memory and cost-free.
• Memory: Only $r_j$1 tokens loaded in context; complete trajectory corpus $r_j$2 stored off-context, requiring $r_j$3 memory.
• Runtime: Tool lookups are $r_j$4 worst-case, with practical indexing yielding sublinear access times (Lee et al., 13 Apr 2026).

In distributed optimization, AggAgent offers global linear convergence rates under strong convexity and Lipschitz gradient assumptions, robust to delays, network sparsity, and parameter perturbation (Liu et al., 30 Mar 2025). Local acceleration reduces the needed iterations multiple times versus non-accelerated gradient tracking.

Within fleet supervision, the agentic layer solves the MIP only as triggered by the disturbance agent, minimizing unnecessary reevaluation. Coordination modes permit explicit bounding of arbitrage margins or PTO costs, facilitating scalable policy adaptation and rapid response to operational disturbances (Manzolli et al., 24 Jun 2026).

5. Empirical Benchmarks and Comparative Evaluation

In long-horizon reasoning, AggAgent was evaluated over six benchmarks (BrowseComp, BrowseComp-Plus, HLE, DeepSearchQA, Healthbench-Hard, ResearchRubrics) using three LLM families (GLM-4.7, Qwen3.5, MiniMax-M2.5):

Method	GLM-4.7	Qwen3.5	MiniMax-M2.5
Pass@1	30.0%	40.2%	44.0%
SolAgg@8	42.6%	52.8%	54.9%
SummAgg@8	41.2%	51.7%	53.9%
AggAgent@8	47.9%	55.8%	57.3%

Average absolute gain over the best baseline at $r_j$5 was $r_j$6, with $r_j$7 on deep-research tasks. Solution aggregation or summary aggregation imposed an additional $r_j$8 cost, whereas AggAgent added just $r_j$9 (Lee et al., 13 Apr 2026).

Distributed optimization tests showed that DAGT-HB and DAGT-NES reach $a_j$0 error substantially faster than prior methods, retain stability under increased momentum (to the limit imposed by Jury criteria), and maintain performance under delays and sparse graphs (Liu et al., 30 Mar 2025).

Electric bus fleet studies reported PTO daily cost reductions from 218.10 EUR (“dumb” charging) to as low as 118.91 EUR (operational-based AggAgent), with explicit trade-offs in aggregator revenue, V2G exchange, and tariff spreads governed by the chosen coordination mode. Under real-time disturbance, dynamic triggering limited unnecessary re-optimization while preserving schedule feasibility and minimizing cost (Manzolli et al., 24 Jun 2026).

6. Design Principles, Trade-offs, and Policy Implications

Key insights across AggAgent instantiations include:

• Full-fidelity evidence exploitation: By actively inspecting and cross-validating full trajectories, AggAgent outperforms aggregation-by-voting or summary, especially in long-horizon or open-ended tasks.
• On-demand, selective inspection: Focusing high-resolution scrutiny only where disagreement or minority correctness is probable preserves compute and context resources.
• Cost and scalability: Single-pass, bounded context aggregation with free tool-use or distributed momentum-driven updates ensures asymptotic independence from the number of agents or rollouts.
• Transparency and governance: Especially in operational settings, explicit mode encoding, structured communication, and policy-driven agent design are critical for aligning incentives (e.g., aggregator vs PTO), enforcing value-sharing, and maintaining regulator oversight.

A plausible implication is that agentic aggregation architectures generalize beyond cognitive LLM systems to any setting where the orchestration of partially independent, tool-augmented, or policy-driven agents can yield scalable, reliable collective optimization or decision-making.

7. References to ArXiv Implementations

• Long-horizon LLM aggregation: "Agentic Aggregation for Parallel Scaling of Long-Horizon Agentic Tasks" (Lee et al., 13 Apr 2026)
• Distributed optimization momentum acceleration: "Accelerated Distributed Aggregative Optimization" (Liu et al., 30 Mar 2025)
• Agentic supervisory orchestration for fleet operations: "When Agents Meet Electric Bus Fleet Operations: Pricing Behavior, Trade-offs, and Policy Implications in an Aggregator Framework" (Manzolli et al., 24 Jun 2026)