Planner-Executor Multi-Agent Architecture

• Planner-executor multi-agent architecture is a system design that decomposes high-level goals into atomic subtasks and assigns them to specialized executor agents for scalable, parallel processing.
• It employs hierarchical task decomposition and dynamic executor instantiation to handle diverse applications like scientific automation, code synthesis, and navigation with explicit verification and error control.
• The architecture’s modular design, lightweight communication protocols, and feedback-driven control enable robust system performance in high-demand, multi-domain environments.

A planner-executor multi-agent architecture is a system design pattern wherein a central planning agent decomposes high-level goals into structured sub-tasks and delegates their execution to specialized executor agents. This paradigm provides modularity, explicit separation of concerns, and dynamic workflow adaptation, and has become foundational in scientific automation, complex reasoning, scientific computing, navigation, retrieval-augmented generation, code synthesis, and verification tasks. The architecture is characterized by dynamic task decomposition (often via hierarchical or recursive approaches), runtime instantiation of dedicated executor agents with tailored toolsets, and inter-agent protocols ensuring parallelism, error propagation control, and robust scalability.

1. Core Architecture and Workflow

A prototypical planner-executor system consists of a central planning agent and multiple dynamically instantiated executors. The planner receives a user’s root request and leverages a library of tools and agent templates to hierarchically decompose the task via a method such as hierarchical task networks (HTN), topological sort, or recursive goal expansion (Wang et al., 18 Sep 2025). The planner maintains an explicit working-memory file or a dependency graph (DAG) representing subtasks, dependencies, and intermediate results.

Task delegation follows these steps:

1. Task Decomposition: The planner applies a recursive decomposition algorithm (e.g., HTN, layered execution graph, or dependency-aware DAG) to partition the root task into atomic or primitive sub-tasks (Wang et al., 18 Sep 2025, Alzu'bi et al., 2 Feb 2026, Zhao et al., 6 Aug 2025, Xu et al., 24 May 2026).
2. Dynamic Executor Instantiation: For each atomic subtask, the planner configures an executor with a tailored system prompt, specific tool configuration (e.g., tool list, API schema), and a unique I/O contract (Wang et al., 18 Sep 2025, Sun et al., 27 Aug 2025).
3. Parallel and Sequential Scheduling: Executors may be run in FIFO order, batch-parallel, or according to a dependency-preserving schedule, often determined by the structure of the decomposition tree or DAG (Pham et al., 9 Apr 2026, Alzu'bi et al., 2 Feb 2026, Zhao et al., 6 Aug 2025).
4. Execution and Result Propagation: Executors autonomously perform their assigned tasks, invoke external tools (e.g., code execution, simulation engines), and return outputs to the planner. The planner aggregates results, triggers downstream processes, and collates final outputs for the user (Wang et al., 18 Sep 2025, Pham et al., 9 Apr 2026, Xu et al., 24 May 2026).

Message schemas between agents are typically concise JSON packets containing task IDs, tool descriptions, input payloads, and result metadata. Working-memory structures encode hierarchical task state and execution traces for coordination and debugging.

2. Task Decomposition and Planning Algorithms

Planners implement explicit task decomposition, commonly via:

• Hierarchical Task Networks (HTN): Tasks are recursively split into subtasks until only primitives remain. Planning proceeds by topological sorting of leaves subject to dependency constraints. Subtasks inherit context relevant to their branch (Wang et al., 18 Sep 2025).
• Layer Execution Graph (LEG): For multi-track reasoning (e.g., scientific workflows), the planner constructs a LEG—a DAG where nodes are agent invocations, layers are synchronization barriers, and tracks encode parallel logical branches (Zhao et al., 1 May 2026). Barrier semantics ensure that all tasks in layer $k$ are complete before layer $k+1$ begins.
• Directed Acyclic Graphs (DAG): In RAG and search systems, the planner builds a DAG representing sub-queries and their dependencies, optimizing for parallel execution and minimal makespan (Zhao et al., 6 Aug 2025).
• Recursive Open Meta-Agent Decomposition: ROMA uses recursive planner-executor splitting: each node dynamically decides whether to further decompose a subgoal or to delegate it to an executor, maintaining context windows by aggregating only summaries upward (Alzu'bi et al., 2 Feb 2026).

Decomposition considers tool registry inspection, input/output contract formation, format constraints, and, in some systems, explicit verification predicates and behavioral checks for each node in the decomposition graph (Xu et al., 24 May 2026). In some scientific domains, planners incorporate domain-specific heuristics encoded in natural-language prompts for routing and agent selection (Zhao et al., 1 May 2026).

3. Executor Agents, Tool Abstraction, and Adaptive Configuration

Executors in this architecture are instantiated per subtask, with stateless, single-use semantics beyond their input payload. They are configured with:

• System Prompt Templates: Each executor prepares a domain-specific system prompt framing its responsibility (e.g., "You are an agent tasked with extracting alloy compositions…" or "You are evaluating a simulation workflow for a specific parameter sweep" (Wang et al., 18 Sep 2025, Pham et al., 9 Apr 2026)).
• Tailored Toolsets: Executors interface with a minimal subset of tools (APIs, wrappers, code execution sandboxes, simulation engines) required for their designated subtask (Wang et al., 18 Sep 2025); tool access is strictly defined by the planner-generated context.
• Workflow and Control Loop: Upon receiving an execution request, the executor:
  1. Parses the system prompt and loads available tool endpoints.
  2. Executes a single LLM call, which may generate an action plan, including explicit tool call commands.
  3. Bridges LLM output with real tool invocations via a read–think–act orchestration loop.
  4. Returns structured results on completion or error (Wang et al., 18 Sep 2025).

This design robustly accommodates new tools—each tool is added to a central registry and automatically becomes available to the planner's decomposition logic, requiring no code changes in executor instantiation (Wang et al., 18 Sep 2025). Executors are agnostic to memory beyond their immediate context, and their stateless execution ensures scalability.

4. Communication Protocols, Memory, and Feedback Mechanisms

Planner-executor systems rely on lightweight communication protocols for agent orchestration:

• Message Schemas: All inter-agent messages use compact, well-typed JSON schemas containing task IDs, subtask descriptions, input arguments, tool endpoints, and system prompts. Result messages include success/error status, output payloads, log data, and tool usage metrics (Wang et al., 18 Sep 2025, Pham et al., 9 Apr 2026).

• Working-Memory Models: The planner maintains a persistent working-memory tree (or file), capturing the root goal, the decomposition hierarchy, individual subtask states, and back-pointers for stateful dependency management (Wang et al., 18 Sep 2025).
• Feedback-Driven Flow: Results produced by executors immediately update the planner's state, triggering progression to downstream subtasks. Built-in mechanisms handle error propagation, forced replanning, and dynamic adjustment of downstream tasks (Wang et al., 18 Sep 2025, Xu et al., 24 May 2026).
• Parallel Agent Orchestration: Executors are launched as processes or threads to maximize concurrency across independent subbranches of the decomposition tree or DAG (Pham et al., 9 Apr 2026).
• Memory Modules: Across benchmarks, planner memory is observed to dominate clean-task utility, while executor memory has negligible effect; shared or separate memory models produce similar outcomes (Dong et al., 8 Oct 2025). Experiments show utility improvements of 10–30 percentage points when planners are equipped with comprehensive memory modules.

5. Scalability, Performance, and Domain Adaptability

The architecture demonstrates robust scalability in both resource efficiency and domain generality:

• Parallelism and Critical Path: Makespan for DAG-scheduled sub-tasks reflects the length of the critical execution path, not the total number of sub-tasks (Zhao et al., 6 Aug 2025). Parallel efficiency remains high (e.g., 98% up to 32 nodes, 65% at 256 nodes for scientific screening) (Pham et al., 9 Apr 2026). Speedups achieved by parallel scheduling approach the ideal $L_{\mathrm{seq}}/L_{\mathrm{par}}$ ratio.
• Executor Pool Scaling: Planner agents allocate executors according to workload, dynamically partitioning subtasks. Pools of hundreds of executors can be coordinated via Model Context Protocol (MCP) servers or other cluster management backends (Pham et al., 9 Apr 2026).
• Adaptability and Tooling: The planner-executor pattern is tool-agnostic—backends for DFT, GCMC, molecular dynamics, code evaluation, or web interaction can be swapped in by extending the tool registry and adapting system prompts (Wang et al., 18 Sep 2025, Pham et al., 9 Apr 2026).
• Memory and Token Efficiency: Semi-centralized protocols (as in Anemoi) dramatically reduce communication cost, shrinking redundant context passing by up to 75% compared to centralized prompt-passing designs, while improving accuracy by up to 9.09 percentage points over centralized baselines (Ren et al., 23 Aug 2025).
• Domain Generalization: The architecture has been applied to material discovery, web navigation, OS control, adaptive retrieval, GUI automation, scientific reasoning, and claim verification (Pham et al., 9 Apr 2026, Wu et al., 4 May 2026, Chen et al., 1 Aug 2025, Sun et al., 27 Aug 2025, Zhao et al., 1 May 2026).

6. Robustness, Vulnerabilities, and Verification

Despite improved reliability over single-agent protocols, planner-executor architectures expose several vulnerabilities:

• Sensitivity to Planner Quality: Clean-task utility and robustness are dominated by planner quality. Weak planners in otherwise strong systems cause sharper utility drop than the inverse, with utility performance differing by 20–30 percentage points in ablations (Dong et al., 8 Oct 2025).
• Attack Surfaces: Robustness benchmarks reveal that planner-stage prompt injections, system prompt attacks, or communication payload manipulations can lead to high attack success rates—routinely ASR ≥ 70%, with planner prompt corruption propagating failures through the execution tree (Dong et al., 8 Oct 2025, Li et al., 12 May 2026).
• Workflow Steering Attacks: Unique to this architecture, attacks on workflow formation (such as FlowSteer) exploit planning-time vulnerabilities, crafting prompt perturbations that bias the planner into structurally amplifying malicious signals; corresponding defenses (FlowGuard) reduce attack success rates by 18–34 percentage points, with minimal impact on utility (Li et al., 12 May 2026).
• Verification and Error Attribution: Modern frameworks (Meta-Agent, ROMA) integrate construction-time and execution-time verification predicates, explicit input/output contracts per agent, and three-way error attribution (local, upstream, structural) to contain error propagation and support targeted remediation (replan, partial redo, or system re-synthesis) (Xu et al., 24 May 2026, Alzu'bi et al., 2 Feb 2026).
• Interpretability: Zero-shot, chain-of-thought planners (e.g., “MACE”) produce explicit reasoning explanations and step-by-step plans, with execution and verification traces formatted as structured blocks for auditability (Saha et al., 19 Apr 2026).

7. Design Principles and Extensions

Key architectural principles emerging from recent work include:

1. Separation of Concerns: Explicit bifurcation between “what to do” (planner) and “how to do it” (executor), enabling modular reasoning and division of labor (Wang et al., 18 Sep 2025).
2. Hierarchical Decomposition: Recursive partitioning yields depth-limited trees or DAGs with bounded context footprint and scalable parallel execution (Alzu'bi et al., 2 Feb 2026).
3. Tool Abstraction: Every actuator or environment interface is encapsulated as a tool with a standard API, facilitating planner-driven task-tool binding at runtime (Wang et al., 18 Sep 2025).
4. Dynamic Agent Configuration: Executors are instantiated at runtime using prompt templates and tool configurations specific to the subtask (Wang et al., 18 Sep 2025, Sun et al., 27 Aug 2025).
5. Feedback-Driven Control Flow: Results and errors propagate through the planner state, gating downstream actions and supporting robust error recovery (Xu et al., 24 May 2026).
6. Verification and Attribution: Integration of format, behavioral, and logical verification at construction and runtime, with fine-grained error labeling and remediation (Xu et al., 24 May 2026).
7. Memory and Self-Evolution: Bidirectional conversion between parametric (planner-trained) and non-parametric (experience memory) supports on-the-fly self-improvement and test-time adaptation (Qiao et al., 6 Apr 2026).

Design generalizes across domains; by substituting domain-specific toolkits and workflows, the core architecture remains applicable for scientific modeling, RAG, navigation, cyberdefense, and knowledge-intensive procedural tasks (Wang et al., 18 Sep 2025, Udeshi et al., 15 Feb 2025, Chen et al., 1 Aug 2025, Pham et al., 9 Apr 2026).

---

In summary, the planner-executor multi-agent architecture has proven to be a robust, extensible, and high-performance design for orchestrating complex automation with deep reasoning, explicit verification, and multi-tool integration. Its principled modularity, based on hierarchical task decomposition, dynamic executor instantiation, and rigorous feedback channels, underlies advances in robust scientific workflows, adaptive reasoning, scalable retrieval, and practical multi-agent collaboration across a range of specialized and generalist applications (Wang et al., 18 Sep 2025, Alzu'bi et al., 2 Feb 2026, Xu et al., 24 May 2026, Pham et al., 9 Apr 2026).