Planner–Executor Framework

• Planner–Executor Framework is a systems architecture that separates high-level planning from low-level execution, enabling scalable, robust decision-making.
• It uses hierarchical decomposition, timeline-based methods, and adaptive replanning to manage temporal and causal constraints under uncertainty.
• Applications in robotics, manufacturing, GUI automation, and multi-agent systems demonstrate improved efficiency, safety, and dynamic adaptation.

A planner–executor framework is a systems architecture that explicitly separates high-level planning (task decomposition, strategic reasoning) from low-level execution (action realization, operations in the environment), typically featuring a two- or multi-layer design where planning and execution are realized by distinct modules, agents, or processes. Originally motivated by the needs of AI planning and robotics, this separation allows scalable plan generation, robust action execution, and effective handling of environmental uncertainty or dynamic changes.

1. Foundational Architectures and Formalisms

The planner–executor paradigm is grounded in hierarchical decomposition and temporal modeling. In multi-robot systems, a prominent instantiation is the hierarchical two-layer architecture (Ma et al., 2018), where:

• Task-level planning employs AI-based combinatorial search (such as multi-agent path-finding or TAPF) to establish high-level, collision-free plans that disregard specific kinematic constraints for computational scalability.
• Motion-level or execution-level planning augments the high-level plan by introducing kinematic and temporal constraints, compiling these into a Temporal Plan Graph (TPG), and further into a Simple Temporal Network (STN) that encodes causal (precedence) dependencies and quantitative timing constraints (edges marked by intervals $[L_{ij}, U_{ij}]$ for event pairs).

For generalized timeline-based planning, formal trajectory models such as state variables $x = (V, T, \gamma, D)$, tokens $x^i = (v, [e, e'], [d, d'], \gamma(v))$, and synchronization rules (quantified Allen relations) underpin the structure of plans and their execution, supporting flexible token durations, external uncontrollability, and hierarchical abstraction (Umbrico, 2019).

The planner–executor split is also reflected in the orchestration of state machines in GUI automation (e.g., extended finite state machines $\epsilon = (S, E, A, V, T, s_0)$ with explicit path search) (Mo et al., 20 May 2025), symbolic world model simulators (Xiong et al., 2 May 2025), and metareasoning formulations as Markov Decision Processes (MDPs) that model concurrent planning and execution (Elboher et al., 2023).

2. Hierarchical, Modular, and Timeline-Based Approaches

The ability to represent both temporal and causal dependencies across abstraction levels is a central advantage of the planner–executor split.

• In hierarchical systems, functional (high-level), primitive (low-level), and external (uncontrollable environment) layers are connected via synchronization rules and dependency graphs; planning proceeds iteratively, resolving flaws in a top–down manner and refining abstract goals to concrete executions (Umbrico, 2019).
• Timeline-based techniques formalize behavior using tokens and synchronization rules, capturing both controllability (via $\gamma(v)$) and temporal uncertainty (Umbrico, 2019). The execution system (“Executive” or “controller” module) monitors progress, updates token status (waiting, starting, in-execution, executed), and triggers re-scheduling or incremental plan repair as needed.
• In multi-robot scheduling, temporal flexibility (“slack” in the STN) is crucial: it enables the system to absorb execution discrepancies without triggering costly global replanning, by quickly re-solving temporal constraints in polynomial time (Ma et al., 2018).

Distinct planning methodologies such as partial-order plans with adaptable, on-the-fly ordering adaptation (Lima et al., 2020), and plan analysis/repair based on causal links and dynamic “opportunities” discovered at planning time but realized only during execution, further enhance robustness (Borrajo et al., 18 Mar 2024).

3. Adaptation, Closed-Loop Execution, and Dynamic Replanning

Robust plan execution in real-world settings necessitates adaptability to environmental feedback and uncertainty. Core strategies include:

• Closed-Loop Planning/Execution: At every step, the planner receives updated state or observation feedback, re-evaluates the plan, and makes corrections if deviations or out-of-distribution states occur. This is exemplified by closed-loop LLM-based planners for EIF framed as POMDPs with actor-critic modules and adaptation/hindsight techniques (Yang et al., 27 Dec 2024), and by dynamic plan repair upon detecting execution “opportunities” (Borrajo et al., 18 Mar 2024).
• Dynamic Replanning: Rather than adhering rigidly to a precomputed plan, the framework leverages temporal flexibility or partial orderings to adapt action order or skip redundant steps when exogenous events create favorable conditions (Lima et al., 2020).
• In-Plan and Out-of-Plan Refinement: Adaptive frameworks such as AdaPlanner use in-plan refinement for minor observation mismatches (invoking the LLM to repair subplans on the fly) and out-of-plan refinement for major assertion or state failures (triggering full plan regeneration) (Sun et al., 2023).

Efficient plan execution under uncertainty is thus realized by combining baseline plans (derived from state-of-the-art planners), flexible temporal and structural constraints, runtime monitoring, and principled repair or adaptation mechanisms.

4. Applications Across Domains and Performance Outcomes

Planner–executor frameworks have been validated across diverse domains, each highlighting distinct performance outcomes:

• Multi-Robot Systems: In automated warehouse scenarios, hierarchical frameworks coordinate multiple teams (omni-directional vs. differential-drive robots) solving tasks via TAPF, with the STN managing temporal dependencies and kinematic safety (Ma et al., 2018).
• Manufacturing and Human–Robot Collaboration: Timeline-based planners control both machine and human agents in assembly/disassembly tasks, with planning times ranging from seconds up to 30 seconds for 10–15 minute horizons (Umbrico, 2019).
• Web Agents and GUI Automation: Extended finite state machine-based planners in mobile environments yield notable improvements—e.g., a 28.8% increase in AndroidWorld benchmark success rate over VLM-only baselines (Mo et al., 20 May 2025).
• Offensive Security: Multi-agent Planner–Executor frameworks assign heterogeneous executors to subtasks in CTF challenges, achieving state-of-the-art performance (e.g., 22.0% NYU CTF Bench, 65% more MITRE ATT&CK techniques solved compared to prior work) (Udeshi et al., 15 Feb 2025).
• Multi-Hop Reasoning and Retrieval: Two-tier Planner–Executor architectures such as OPERA use RL-trained planners for query decomposition and executors for subgoal retrieval/answering, yielding significant EM score gains—e.g., a 15.9% increase on the 2WikiMultiHopQA benchmark versus the best baseline (Liu et al., 22 Aug 2025).
• Visual Analytics and Multimodal Reasoning: Frameworks such as LightVA (LLM agent-based visual analytics) and VLAgent (text-to-visual reasoning) show that iterative planner–executor coordination, error correction (syntax-semantics parsing, ensemble verification), and user-in-the-loop task management drive robust analytic workflows and substantial accuracy improvements (Zhao et al., 8 Nov 2024, Xu et al., 9 Jun 2025).

A recurring finding is that explicit planning modules—especially when allied with hierarchical or modular execution engines—substantially increase robustness, reduce the need for global replanning, and improve overall system efficiency across settings.

5. Technical Innovations: Symbolic Grounding, Self-Learning, and Tool Integration

Recent innovations focus on enhancing the planner–executor interface using various techniques:

• Symbolic Planning and Verification: Frameworks such as SymPlanner leverage a symbolic environment to ground LLM planning, enforcing domain constraints and enabling deterministic feedback and correction via simulation; iterative correction ensures that only valid action sequences are executed, and contrastive ranking enhances solution diversity and validity (Xiong et al., 2 May 2025).
• Neural-Symbolic and Self-Learning Architectures: In SymAgent, planner and executor modules jointly enable collaborative augmentation between LLMs and knowledge graphs, dynamically synthesizing symbolic rules, executing via tool invocations and environment traversals, and employing a self-learning loop of online exploration and offline SFT policy updates—abolishing the need for manual trajectory engineering (Liu et al., 5 Feb 2025).
• Tool and Module Integration: Agentic frameworks like OctoTools encapsulate external tools via standardized “tool cards,” enabling planners to dynamically select and sequence both high-level and low-level operations. Executors predict and execute tool-specific commands, while toolset optimization algorithms adaptively select the most beneficial tool combinations based on validation accuracy (Lu et al., 16 Feb 2025).

Further extensions such as skill discovery mechanisms (archiving successful plans as few-shot prompts), instance-conditioned planner optimization (OPOF and the Planner Optimization Problem formulation), and fine-tuned on-device planners for edge agents (multi-LoRA adapters, Phi-3 Mini) illustrate the practical spectrum of planner–executor technology (Lee et al., 2023, Chen et al., 26 Jun 2024).

6. Tradeoffs, Limitations, and Open Challenges

Despite their strengths, planner–executor frameworks must address several challenges:

• Tradeoff Between Scalability and Fidelity: Decoupling high-level planning (often computationally feasible due to abstraction) from execution can introduce mismatches; e.g., plans that are theoretically optimal at the symbolic level may not be feasible or robust in the real world. Hierarchical models mitigate this by incremental constraint incorporation, but fidelity sacrifices can still occur (Ma et al., 2018, Umbrico, 2019).
• Need for Accurate World Models and EFSM Construction: Manual modeling of extended finite state machines or symbolic representations for arbitrary environments is labor-intensive (Mo et al., 20 May 2025, Xiong et al., 2 May 2025). Automatic graph or model induction remains an open area.
• Coordination and Communication Overhead: As frameworks scale to multi-agent or multi-domain settings, maintaining coherent plan-executor synchronization and avoiding conflicting action assignments or context drifts require sophisticated executive control and context management (Udeshi et al., 15 Feb 2025, Liu et al., 22 Aug 2025).
• Tool Integration and Verification: While modular tool integration (OctoTools, VLAgent) increases extensibility, it places pressure on planners to accurately predict module pre/post-conditions, and on executors to correctly handle failure cases and manage ensemble outputs (Lu et al., 16 Feb 2025, Xu et al., 9 Jun 2025).

These limitations motivate active research into automated model learning, more tightly coupled planning-execution loops, improved context management, and adaptive reinforcement learning protocols for multi-agent planner–executor systems.

7. Future Directions and Impact

Planner–executor frameworks are central to the development of autonomous, robust, and scalable AI agents. The decoupled yet coordinated architecture supports principled abstraction, tractable reasoning under uncertainty, and actionable execution in open-world environments. Ongoing work on symbolic representation, closed-loop adaptation, tool-integration, and multi-agent coordination continues to drive the field forward. Their demonstrated benefits in robotics, web automation, cybersecurity, visual reasoning, analytics, and beyond firmly establish the planner–executor framework as a foundational paradigm in both theoretical and practical AI system design.