Agent–Planner–Executor–Summarizer Pipeline

• The Agent–Planner–Executor–Summarizer pipeline is a modular framework that decomposes complex tasks into orchestrated roles, enhancing clarity and adaptability.
• It enables efficient role specialization through setups like LoRA-based adaptation and reward-driven scheduling, which improve both performance and interpretability.
• Empirical results from systems like MoRAgent, JADE, and GraphPlanner demonstrate significant gains in benchmark tasks and resource optimization.

An Agent–Planner–Executor–Summarizer pipeline is a modular agentic architecture that decomposes complex reasoning and decision-making into distinct functional stages: (1) an agent or controller orchestrates a workflow; (2) a planner or reasoner determines strategic decomposition or next actions; (3) executors implement low-level operations or environmental interactions; and (4) a summarizer integrates, distills, or communicates results. This decomposition reflects a shift from monolithic models toward structured multi-role workflows and is central to state-of-the-art systems in tool-augmented language agents (Han et al., 25 Dec 2025), open-domain search (Jin et al., 3 Jul 2025), dynamic RAG (Chen et al., 29 Jan 2026), multi-agent LLM routing (Feng et al., 26 Apr 2026), and modular perceptual pipelines (Zhu et al., 30 Sep 2025). The pipeline enables efficient specialization, improved interpretability, parameter-efficient adaptation, and synergy between planning and operational execution.

1. Conceptual Foundations and Role Definitions

The canonical Agent–Planner–Executor–Summarizer pipeline assigns clear boundaries to each module, often manifested as logically distinct yet tightly coupled roles:

• Agent/Controller: Oversees the interaction, maintains the global trace or context, and coordinates the overall workflow. In systems such as JADE (Chen et al., 29 Jan 2026) and HiRA (Jin et al., 3 Jul 2025), the agent module is responsible for maintaining full workflow state and triggering Planner and Executor modules according to the reasoning trace or external observations.
• Planner/Reasoner: Decomposes queries or tasks into actionable subtasks, produces high-level reasoning "thoughts," trajectories, or structured plans. For instance, MoRAgent's reasoner emits a natural-language analysis and a control-flow signal indicating whether to invoke the Executor or Summarizer (Han et al., 25 Dec 2025). Planners operate over sequences of subtasks (Jin et al., 3 Jul 2025), or generate dynamic workflow graphs (Chen et al., 29 Jan 2026), and optimize for both efficiency and accuracy.
• Executor: Selects and applies low-level operations (e.g., function calls, retrievals, tool invocations) to effect real or simulated state transitions. This module acts as the workhorse: in GraphPlanner, the Executor is assigned by both role and LLM backbone and produces outputs for atomic or composite queries (Feng et al., 26 Apr 2026).
• Summarizer: Aggregates, distills, or synthesizes information from completed subtasks or full execution trajectories into concise, user-facing answers or structured outputs. In tool-augmented and perceptual systems, the Summarizer integrates quantitative and qualitative evidence to yield scalar predictions and natural-language explanations (Zhu et al., 30 Sep 2025).

The clear isolation of roles enables each module to be optimized for its specific operational context, whether via prompt engineering, parameter-efficient adaptation, or role-specific policies.

2. Architectural Implementations Across Domains

Several reference architectures exemplify the agent–planner–executor–summarizer paradigm:

MoRAgent: Mixture-of-Roles LoRA Agents

MoRAgent assigns each of the three roles (reasoner/planner, executor, summarizer) a dedicated family of trainable Low-Rank Adaptation (LoRA) adapters atop a frozen LLM backbone. At each timestep, only one role's adapters are active, and token-level routing selects among multiple LoRA "expert" modules specializing in that role. This setup enables parameter-efficient fine-tuning and modular adaptation. The agent's control flow consists of the reasoner producing a plan and decision signal, executor performing tool actions, and summarizer terminating the dialog with a distilled summary (Han et al., 25 Dec 2025).

JADE: Fully Joint Dynamic Multi-Agentic RAG

JADE operationalizes the architecture as a cooperative multi-agent team with agent, planner, executor, and summarizer roles all unified under a single shared LLM backbone. All gradients flow jointly, enabling strategic (planner) and operational (executor) layers to co-adapt, unlike models with decoupled, frozen modules. The planner outputs dynamic workflow graphs, the executors implement both decomposition (serial or parallel) and solving (retriever, answer generator, query rewriter), while the summarizer fuses the entire answered trace to produce the final result (Chen et al., 29 Jan 2026).

GraphPlanner: Heterogeneous Graph Routing

GraphPlanner formalizes the pipeline as an MDP, where an agentic router selects both the current role (planner, executor, summarizer) and an LLM backbone at each step. A dual heterogeneous graph memory tracks interactions. The planner performs semantic query decomposition, executors answer atomic sub-queries, and the summarizer condenses multi-branch outputs. Reinforcement learning jointly optimizes efficiency and accuracy (Feng et al., 26 Apr 2026).

HiRA: Hierarchical Decoupling

HiRA decouples the high-level reasoning (Planner) from execution by domain-specialized agents. The coordinator mediates subtask assignment, executor outputs are distilled and summarized, and integration is executed via structured feedback loops. This structure improves efficiency and robustness relative to monolithic agent designs (Jin et al., 3 Jul 2025).

AgenticIQA: Modular Perceptual Reasoning

AgenticIQA applies the pipeline to visual quality assessment. The planner generates a strategy (e.g., distortion detection, analysis steps), the executor orchestrates expert tool calls, intermediate outputs are synthesized, and the summarizer fuses multi-source cues into a scalar score and human-aligned rationale (Zhu et al., 30 Sep 2025).

3. Data Generation, Training Objectives, and Optimization

Pipeline implementations require datasets with rich annotations reflecting all pipeline stages. For example, MoRAgent reconstructs missing reasoner and summarizer annotations using role-specific prompting of GPT-4o and rigorous reliability filtering (e.g., DeepSeek-V3 scoring, executor error correction) to serialize full role-based interaction traces. Data is stored in a JSON schema specifying step-by-step role assignments, actions, and observations (Han et al., 25 Dec 2025).

Training objectives combine token-level cross-entropy with auxiliary losses to balance expert utilization and encourage orthogonality among LoRA adapters, as in MoRAgent:

• $$L_{total} = L_{CE} + \alpha_1 L_{aux} + \alpha_2 L_{orth}$$,

where $L_{CE}$ is standard cross-entropy, $L_{aux}$ enforces uniform use of experts, and $L_{orth}$ penalizes redundancy among adapters (Han et al., 25 Dec 2025).

In RL formulations (GraphPlanner, JADE), reward signals encode both final task utility and stepwise efficiency or format penalties, and policy gradients (PPO) are used for end-to-end optimization. Global rewards can balance answer correctness against computation cost through tunable coefficients (Feng et al., 26 Apr 2026, Chen et al., 29 Jan 2026).

4. Workflow Dynamics: Control Flow, Scheduling, and Interaction

The agent–planner–executor–summarizer pipeline implements dynamic, multi-round workflows with explicit dispatching at each decision point. For example:

• In MoRAgent, execution alternates between reasoner, executor, and, upon termination, summarizer modules, with each step determined by the previous module's output and full trajectory. The gating ensures that only one role is active per token, controlled by explicit Role signals (Han et al., 25 Dec 2025).
• JADE orchestrates topological traversal of the dynamically constructed workflow graph at each reasoning round, executing decomposers and solvers, maintaining context, and delegating final synthesis to the summarizer, with role-specific prompts differentiating policy behavior (Chen et al., 29 Jan 2026).
• GraphPlanner uses a Markov Decision Process, where the router selects (role, backbone) pairs according to masked, semantically validated action space, tracking both current state and workflow history in its heterogeneous graph. Node types encode queries, responses, and role-hubs, and message-passing updates contextualized embeddings at each step (Feng et al., 26 Apr 2026).

Workflow generation and executive scheduling thus become learnable, often reward-driven, policies rather than statically defined heuristic sequences.

5. Empirical Performance and Comparative Outcomes

Published results across reference implementations highlight the empirical benefits of agent–planner–executor–summarizer pipelines:

System	Key Benchmark(s)	Performance Gains
MoRAgent (Han et al., 25 Dec 2025)	StableToolBench, BFCL, GSM8K, MATH	+35–53 pp over base on tool tasks; +12–18 pp on math (Qwen2.5-1.5B)
JADE (Chen et al., 29 Jan 2026)	7 RAG QA datasets	Avg. F1: 53.86 vs. 45.57 (best baseline); +8.29 F1; robust to efficiency trade-offs
GraphPlanner (Feng et al., 26 Apr 2026)	14 LLM tasks, multiple LLMs	Avg. Acc: 63.6% (+9.3%) vs. best single-round baseline; GPU use 1.04 vs 186.26GiB
HiRA (Jin et al., 3 Jul 2025)	4 cross-modal search tasks	+6.3 GAIA on GAIA; ~30% token and ~40% env-call reduction
AgenticIQA (Zhu et al., 30 Sep 2025)	TID2013, BID, AGIQA-3K, custom evals	Surpasses strong baselines in accuracy and explanation alignment

A key theme is that joint or decoupled multi-role architectures, especially with role specialization and adaptive routing, can match or outperform monolithic and static modular baselines—with strong gains in efficiency and generalizability.

6. Extensions, Generalization, and Research Directions

Agent–Planner–Executor–Summarizer pipelines generalize across modalities (text, vision), domains (RAG, structured query, perceptual reasoning), and system designs (parameter-efficient LoRA, reinforcement learning, graph memory). Notably, they are compatible with both inductive (stateless) and transductive (memory-augmented) inference (Feng et al., 26 Apr 2026), support flexible augmentation with new tools or executor types (Jin et al., 3 Jul 2025), and enable fine-grained interpretability through modular trace outputs.

Performance ablations indicate that pipeline efficiency, modularity, and summary quality depend crucially on robust data annotation for each role, careful coupling between planner and executor adaptation (to prevent strategic–operational mismatch (Chen et al., 29 Jan 2026)), and principled workflow scheduling policies.

Empirical results across multiple research groups confirm that modular decomposition and agentic orchestration, as instantiated in the agent–planner–executor–summarizer paradigm, represent a dominant and extensible pattern for future agent system design.