Planner–Executor–Evaluator Loop

• The Planner–Executor–Evaluator Loop is a modular architecture that separates high-level planning, grounded execution, and dynamic feedback evaluation.
• It integrates step-wise action execution with state monitoring and corrective feedback to ensure robust autonomous operation.
• Recent variants incorporate hierarchical decomposition, probabilistic modeling, and neural-symbolic techniques to enhance performance in robotics and LLM-driven tasks.

The Planner–Executor–Evaluator Loop is a canonical control and reasoning architecture that structures problem-solving in sequential, feedback-driven cycles. This paradigm delineates an agent’s capabilities into three functional roles: (1) the Planner, which constructs a high-level plan or evaluation rubric; (2) the Executor, which carries out or simulates each step of the plan; and (3) the Evaluator, which checks state, detects deviations or failures, and issues corrective feedback. Foundational to robust autonomy, this model supports adaptive closed-loop operation in robotics, neuro-symbolic reasoning, evaluative LLMs, and embodied task planning. Modern variants—ranging from LLM-driven self-corrective planners to multi-modal neuro-symbolic agents—enhance this loop with hierarchical structure, causal memory, and preference-driven optimization.

1. Core Structure and Functional Roles

The Planner–Executor–Evaluator loop enforces functional modularity by separating (i) plan generation, (ii) step-wise grounded execution, and (iii) state-aware comparison and error detection. Each module operates as follows:

• Planner: Receives the initial goal or task instruction and produces a decomposed sequence of actions, semantic subgoals, or diagnostic criteria. Planning may adopt code-style representations (as in AdaPlanner (Sun et al., 2023)), policy rollouts (as in UPOM (Patra et al., 2020)), hierarchical semantic actions (HiCRISP (Ming et al., 2023)), probabilistic evaluation rubrics (EvalPlanner (Saha et al., 30 Jan 2025)), PDDL domain generation (LOOP (Virwani et al., 18 Aug 2025)), or neuro-symbolic script composition (VLAgent (Xu et al., 9 Jun 2025)).
• Executor: Expands plan elements into concrete actions or environment API calls, collecting state feedback. This may include dispatch layers for motion primitives, Pythonic code execution, simulator interfacing, or invoking classical planners.
• Evaluator: Monitors entropy in the actual world or agent trace, detects discrepancies, evaluates assertions, and produces a diagnostic signal—Boolean flags, information strings, metric violations, or corrections—for subsequent feedback.

Critically, the loop design supports interaction over multiple temporal and abstraction levels, from high-level re-planning down to step-wise error recovery. Table 1 summarizes representative architectures:

Framework	Planner Style	Executor	Evaluator/Feedback
HiCRISP	LLM semantic MDP	ROS primitives	Boolean+info, 2-level
AdaPlanner	Pythonic LLM code	Text env API	Assertions, error msg
SDA-PLANNER	LLM + dep. graph	Motor primitives	Pre/effect, Source trace
LOOP	GNN + PDDL	Classical planner	Multi-agent, causal mem.
EvalPlanner	LLM evaluation plan	CoT trace exec	Marginal verdict dist.

2. Hierarchical and Multi-Level Variants

Recent developments hybridize the loop with hierarchical decomposition and dual feedback layers. For instance, HiCRISP (Ming et al., 2023) models task planning as a finite Markov Decision Process $S = \{s_0,...,s_{n+1}\}, A = \{a_0,...,a_n\}$, where the Planner emits a chain of semantic actions, each further expanded into trajectory primitives for the Executor. Both high-level (plan transition, semantic failures) and low-level (primitive deviation, pre/post-condition violation) feedback paths are explicitly handled. HiCRISP maintains a correction stack with capped depth $D$ to prevent infinite error recovery. SDA-PLANNER (Shen et al., 30 Sep 2025) formalizes mid-level action dependencies in a state-dependency graph, enabling localized subtree replanning and precise error backtracking.

VLAgent (Xu et al., 9 Jun 2025) extends this pattern to multi-modal visual reasoning, decomposing tasks into executable scripts via in-context LLM prompting, followed by module-based execution, and then semantic and ensemble verification.

3. Probabilistic and Optimization-Based Instances

The loop’s statistical generalization underpins evaluation systems such as EvalPlanner (Saha et al., 30 Jan 2025), which factor judgment into:

1. Plan sampling: $z \sim p_\theta(z|x)$,
2. Execution: $e \sim p_\theta(e|z, x, a, b)$,
3. Final verdict: $y \sim p_\theta(y|e, z, x, a, b)$,

where $x$ is the instruction, $a,b$ are responses, $z$ a latent plan, $e$ an execution trace, and $y$ the preferred response. This setup treats the plan and trace as latent variables and employs preference optimization (Direct Preference Optimization, DPO) to learn effective evaluation sequences. Systematic reward model accuracy improvements follow decoupling plan generation from stepwise execution.

LOOP (Virwani et al., 18 Aug 2025) treats planning as an iterative neural-symbolic dialogue, with GNN-derived embeddings producing PDDL specifications, classical execution, evaluation via multi-agent validators, and feedback through a causal memory. Symbolic metrics include unsatisfied preconditions ($m_{\text{pre}}$), unmet goals ($m_{\text{goal}}$), and hallucinated fluents ($h_{\text{hall}}$). Memory update is driven by observed plan/trace triples, with weights updated through binary-cross-entropy.

4. Error Detection, Diagnosis, and Correction

Error detection schemes vary in granularity and formalism but universally close the loop via structured feedback to the Planner. HiCRISP (Ming et al., 2023) differentiates between:

• High-level error: Planner generated correct semantics, but perception finds $δ(s_{i+1}, s_\text{perceived}) < θ_{HL}$.
• Low-level error: Primitive’s intrinsic check $$E_\text{primitive}(x) = \|x_\text{actual} - x_\text{target}\| > ε_\text{primitive}$$.

Upon failure, stack-based correction is triggered. SDA-PLANNER (Shen et al., 30 Sep 2025) explicitly models error causality using state backtracking and reconstructs only affected action subtrees, maximizing locality and robustness.

AdaPlanner (Sun et al., 2023) employs in-plan refinements via $ask\_LLM()$ calls and out-of-plan corrections triggered by assertion failures. Skill discovery and feedback inform future plan sampling and code prompt construction.

In LOOP (Virwani et al., 18 Aug 2025), symbolic evaluation pinpoints missing preconditions or hallucinated actions, and plan refinements are automatically inserted via causal memory integration.

5. Empirical Performance and Theoretical Properties

Quantitative evaluation across domains demonstrates the efficacy of tightly integrated planning-execution-evaluation:

• HiCRISP: Raises execution rates from ≈0.71 to 0.90 and success rate by up to +0.21 in VirtualHome; full correction increases execution to 1.00 in PyBullet block stacking (Ming et al., 2023).
• EvalPlanner: Achieves 93.9% on RewardBench, outperforming self-taught judges and constrained baseline models (Saha et al., 30 Jan 2025).
• SDA-PLANNER: Achieves highest success (SR=41.27%) and goal completion (GC=50.92%) on ALFRED, with low average local correction count (Shen et al., 30 Sep 2025).
• LOOP: Outperforms all LLM+planning or search-based baseline (SR=85.8% vs. 55.0% LLM+P, 19.2% LLM-as-Planner, 3.3% Tree-of-Thoughts; (Virwani et al., 18 Aug 2025)).
• UPOM-based systems: Achieve convergence to optimal methods under static domains and reduce retry ratios while raising overall efficiency as neural evaluators are refined (Patra et al., 2020).

Theoretically, proofs of convergence, correctness under symbolic feedback, and reduced error propagation have been established, notably mapping planning rollouts in UPOM (Patra et al., 2020) to finite-horizon UCT convergence.

6. Variants, Integration Modalities, and Future Directions

Loop realizations span classical symbolic AI, code-driven LLM environments, vision-language agents, and neuro-symbolic planning. Integration strategies combine:

• Hierarchical decomposition with local and global feedback (HiCRISP (Ming et al., 2023), SDA-PLANNER (Shen et al., 30 Sep 2025)).
• Causal memory and neural feature injection (LOOP (Virwani et al., 18 Aug 2025)).
• Prompt-engineered LLM code with assertion-driven evaluation and skill library accumulation (AdaPlanner (Sun et al., 2023), VLAgent (Xu et al., 9 Jun 2025)).
• Probabilistic modeling over latent plans/execution (EvalPlanner (Saha et al., 30 Jan 2025)).
• Monte Carlo Tree Search over operational models (UPOM (Patra et al., 2020)).

Future research will likely advance hierarchical LLM-agent hybridization, tighter perception-action-correction integration (potentially via program synthesis), more efficient diagnostic metrics, and learning-driven causal mechanisms. A plausible implication is ongoing expansion into open-world embodied settings, requiring dynamically adaptive, multi-source loop architectures.

7. Comparative View and Theoretical Implications

Direct comparison of loop architectures reveals marked performance benefits for implementations that maintain real iterative feedback, causal memory, and symbolic validation, as summarized below (adapted from LOOP (Virwani et al., 18 Aug 2025)):

Method	Iterative Loop?	Symbolic Feedback	Causal Memory	Neural Features
LLM+P (one-shot)	No	None	No	None
LLM-as-Planner	One-shot	None	No	None
Tree-of-Thoughts	Search	No	No	None
LOOP	Yes	Multi-Agent	Yes	13 modules

This suggests that sustained closed-loop interaction between modules—rather than one-shot translation or search—delivers both logical soundness and empirical robustness, especially as environments increase in complexity and unpredictability.

---

References:

• HiCRISP: Hierarchical Closed-loop Robotic Intelligent Self-correction Planner (Ming et al., 2023)
• AdaPlanner: Adaptive Planning from Feedback (Sun et al., 2023)
• SDA-PLANNER: State-Dependency Aware Adaptive Planner (Shen et al., 30 Sep 2025)
• LOOP: Plug-and-Play Neuro-Symbolic Framework (Virwani et al., 18 Aug 2025)
• EvalPlanner: Planning & Reasoning for Evaluation (Saha et al., 30 Jan 2025)
• VLAgent: Language-Vision Planner and Executor (Xu et al., 9 Jun 2025)
• Deliberative Acting, Online Planning and Learning with Hierarchical Operational Models (Patra et al., 2020)