---
title: Planner–Executor–Evaluator Loop
url: https://www.emergentmind.com/topics/planner-executor-evaluator-loop-746d28a8-0ffd-47e3-ae72-e0b1a75418b5
type: topic
---

# Planner–Executor–Evaluator Loop

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 [2305.16653]), policy rollouts (as in UPOM [2010.01909]), hierarchical semantic actions (HiCRISP [2309.12089]), probabilistic evaluation rubrics (EvalPlanner [2501.18099]), PDDL domain generation (LOOP [2508.13371]), or neuro-symbolic script composition (VLAgent [2506.07778]).
- **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 [2309.12089] 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 [2509.26375] formalizes mid-level action dependencies in a state-dependency graph, enabling localized subtree replanning and precise error backtracking.

VLAgent [2506.07778] 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 [2501.18099], 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 [2508.13371] 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 [2309.12089] 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 [2509.26375] explicitly models error causality using state backtracking and reconstructs only affected action subtrees, maximizing locality and robustness.

AdaPlanner [2305.16653] 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 [2508.13371], 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 [2309.12089].
- EvalPlanner: Achieves 93.9% on RewardBench, outperforming self-taught judges and constrained baseline models [2501.18099].
- SDA-PLANNER: Achieves highest success (SR=41.27%) and goal completion (GC=50.92%) on ALFRED, with low average local correction count [2509.26375].
- 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; [2508.13371]).
- UPOM-based systems: Achieve convergence to optimal methods under static domains and reduce retry ratios while raising overall efficiency as neural evaluators are refined [2010.01909].

Theoretically, proofs of convergence, correctness under symbolic feedback, and reduced error propagation have been established, notably mapping planning rollouts in UPOM [2010.01909] 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 [2309.12089], SDA-PLANNER [2509.26375]).
- Causal memory and neural feature injection (LOOP [2508.13371]).
- Prompt-engineered LLM code with assertion-driven evaluation and skill library accumulation (AdaPlanner [2305.16653], VLAgent [2506.07778]).
- Probabilistic modeling over latent plans/execution (EvalPlanner [2501.18099]).
- Monte Carlo Tree Search over operational models (UPOM [2010.01909]).

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 [2508.13371]):

| 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 [2309.12089]
- AdaPlanner: Adaptive Planning from Feedback [2305.16653]
- SDA-PLANNER: State-Dependency Aware Adaptive Planner [2509.26375]
- LOOP: Plug-and-Play Neuro-Symbolic Framework [2508.13371]
- EvalPlanner: Planning & Reasoning for Evaluation [2501.18099]
- VLAgent: Language-Vision Planner and Executor [2506.07778]
- Deliberative Acting, Online Planning and Learning with Hierarchical Operational Models [2010.01909]

Source: https://www.emergentmind.com/topics/planner-executor-evaluator-loop-746d28a8-0ffd-47e3-ae72-e0b1a75418b5