---
title: Agent–Planner–Executor–Summarizer Pipeline
url: https://www.emergentmind.com/topics/agent-planner-executor-summarizer-pipeline
type: topic
---

# Agent–Planner–Executor–Summarizer Pipeline

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 [2512.21708], open-domain search [2507.02652], dynamic RAG [2601.21916], multi-agent LLM routing [2604.23626], and modular perceptual pipelines [2509.26006]. 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 [2601.21916] and HiRA [2507.02652], 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 [2512.21708]. Planners operate over sequences of subtasks [2507.02652], or generate dynamic workflow graphs [2601.21916], 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 [2604.23626].

- **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 [2509.26006].

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 [2512.21708].

### 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 [2601.21916].

### 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 [2604.23626].

### 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 [2507.02652].

### 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 [2509.26006].

## 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 [2512.21708].

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 [2512.21708].

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 [2604.23626, 2601.21916].

## 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 [2512.21708].

- 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 [2601.21916].

- 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 [2604.23626].

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 [2512.21708]   | StableToolBench, BFCL, GSM8K, MATH      | +35–53 pp over base on tool tasks; +12–18 pp on math (Qwen2.5-1.5B)         |
| JADE [2601.21916]   | 7 RAG QA datasets                        | Avg. F1: 53.86 vs. 45.57 (best baseline); +8.29 F1; robust to efficiency trade-offs |
| GraphPlanner [2604.23626] | 14 LLM tasks, multiple LLMs               | Avg. Acc: 63.6% (+9.3%) vs. best single-round baseline; GPU use 1.04 vs 186.26GiB |
| HiRA [2507.02652]      | 4 cross-modal search tasks               | +6.3 GAIA on GAIA; ~30% token and ~40% env-call reduction                   |
| AgenticIQA [2509.26006] | 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 [2604.23626], support flexible augmentation with new tools or executor types [2507.02652], 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 [2601.21916]), 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.

Source: https://www.emergentmind.com/topics/agent-planner-executor-summarizer-pipeline