---
title: Planner-Refiner Architecture
url: https://www.emergentmind.com/topics/planner-refiner
type: topic
---

# Planner-Refiner Architecture

A Planner-Refiner architecture is a two-stage or multi-stage framework in which an initial solution produced by a "planner" module is systematically improved, transformed, or adapted by a subsequent "refiner" module. The Planner-Refiner paradigm appears across decision-making, path/motion planning, vision-language alignment, automated agent design, and general domain-independent planning. Although specific implementations vary, the core methodology decouples (often fast or symbolic) initial solution synthesis from higher-fidelity, resource-intensive, or data-driven optimization and adaptation.

## 1. Definition and Abstract Structure

A Planner-Refiner framework operates by generating an initial solution (plan, path, trajectory, alignment, or strategy) using a "planner" stage—typically fast, low-resolution, or symbolic—and then applying one or more "refiner" stages to produce improved solutions satisfying stricter constraints or exhibiting higher performance. This division supports modularity, any-time operation, and the ability to leverage disparate representations or solvers.

Common structural features:
- Clearly separated modules for initial plan generation and iterative/targeted refinement.
- The planner may produce valid but suboptimal solutions, which are then improved or made more actionable by the refiner.
- Refinement can be explicit (rewriting, optimization, constraint satisfaction, LLM-based polishing), iterative (multi-agent local improvement), or guided by domain-specific objectives.

This abstraction is instantiated with rigorous mathematical formalism in domains as diverse as robotic motion planning [2309.08897, 2403.12865], multi-agent systems [2102.12331], language-based agents [2305.16653, 2505.14141], vision-language alignment [2508.07330], and general symbolic planning [1106.0250].

## 2. Key Methodological Archetypes

### a) Task and Motion Planning (MR-TAMP)
- The initial symbolic plan specifies high-level sequences for each robot (e.g., pick-and-place actions).
- The refiner solves a Hybrid Constraint Satisfaction Problem (H-CSP) to find geometrically feasible, collision-free, and temporally consistent continuous trajectories.
- Constraints are only enforced where necessary, minimizing coordination overhead to maximize the feasible solution space.
- The refinement proceeds via a multi-stage decomposition: placement, grasp/transit, individual motion, and composite motion, each refining feasibility and coordination [2309.08897].

### b) Domain-Independent Planning by Rewriting
- The planner produces a complete but potentially low-quality plan using a fast (sometimes greedy) algorithm.
- The refiner applies declaratively specified rewriting rules under local search (first/best improvement, simulated annealing, etc.) to incrementally optimize plan quality with respect to a domain-specific metric (e.g., cost, makespan, resource use) [1106.0250].

### c) Iterative Refinement in Multi-Agent Pathfinding
- A planner (e.g., PIBT+) quickly generates a feasible but suboptimal set of plans for all agents.
- The refiner repeatedly selects subsets of agents, fixes the rest, and applies optimal solvers locally to reduce global cost, leveraging domain-tailored selection strategies (e.g., focusing-at-goals, multi-valued decision diagrams) [2102.12331].

### d) Vision-Language Alignment
- The planner decomposes complex queries (sentences) into a sequence of noun-phrase/verb-phrase pairs (atomic actions).
- The refiner takes each semantic unit and guides self-attention over visual tokens in space and time, iteratively improving the representation for downstream alignment tasks [2508.07330].

### e) LLM-based Interactive Agents
- The planner (LLM) synthesizes an executable plan (often code-style or formalized sequence).
- The refiner adaptively revises the plan, either through in-plan updates (local correction) or out-of-plan updates (plan suffix regeneration), in response to environmental feedback and assertion checking. A skill memory may be leveraged for few-shot improvements [2305.16653, 2505.14141].

### f) Robotics Trajectory Generation
- The global planner computes a kinodynamically feasible but piecewise-linear or coarse trajectory.
- The refiner applies B-spline smoothing and local model-predictive control routines, with advanced safety and disturbance rejection constraints, to yield robust, high-speed execution [2403.12865].

## 3. Formal Frameworks and Mathematical Substrates

Across the literature, Planner-Refiner systems are grounded in formal models:

- **Hybrid Constraint Satisfaction Problems (H-CSPs):** For MR-TAMP, planning is formulated over configuration, grasp, and pose variables with discrete, continuous, and global constraints.
- **Partial Order Planning and Rewriting:** In PbR, plan graphs are manipulated via explicit transformation rules, with plan validity and cost as the central metrics.
- **State Machine Traversal:** Mobile GUI agent planners rely on extended finite state machines (EFSMs), traversed to generate candidate execution paths prior to language-based polishing [2505.14141].
- **Graph-based Pathfinding and Local Subproblem Optimization:** Multi-agent and robotics planners leverage graph search (A*, PRM) and iterative, fixed-neighborhood refinement.
- **Sequential and Recurrent Neural Modules:** Vision-language Planner-Refiner decomposes language and applies neural refinement operators conditioned on semantic parses.

These frameworks privilege well-defined interfaces and adherence to domain-specific constraints, with refinement ensuring feasibility or quality where initial planning may sacrifice optimality for speed.

## 4. Theory, Performance, and Complexity

Planner-Refiner architectures offer tractable performance and anytime behavior in settings where monolithic optimal planning is computationally prohibitive:
- In MR-TAMP, the refinement problem is PSPACE-hard, but decomposition and minimal coordination constraints yield scalability and solution space maximization [2309.08897].
- In domain-independent planning, PbR admits no global optimality guarantees (in general), but incremental rewriting produces near-optimal plans orders of magnitude faster than exhaustive or monolithic planners [1106.0250].
- In multi-agent pathfinding, anytime operation is preserved, convergence is empirically fast, and monotonic cost reduction is guaranteed per-refinement [2102.12331].
- In language agents, closed-loop Planner-Refiner substantially improves task success and sample efficiency, demonstrated by >25pp improvements and orders-of-magnitude sample reductions on benchmarks [2305.16653, 2505.14141].
- In robotics, decomposition (A* to B-spline to model predictive contouring control) supports real-time, disturbance-tolerant, and safe trajectories at high speeds [2403.12865].

## 5. Empirical Results and Impact

Domain           | Planner Role         | Refiner Role            | Key Outcome(s)
-----------------|---------------------|-------------------------|-------------------------------
Multi-Robot TAMP | Symbolic task plan   | Geometric H-CSP         | 30% makespan reduction, >90% early pruning [2309.08897]
PbR              | Fast full plan       | Local rewriting+search  | ≈1.1–1.2× optimal, anytime [1106.0250]
MAPF             | Suboptimal solution  | Iterative local opt     | Near-optimal (<2% gap), 1000+ agents [2102.12331]
Vis-Lang Align   | Parse query (NP/VP)  | Space-time attention    | +7–10pp vs SOTA on complex queries [2508.07330]
GUI Agent        | EFSM path (LLM)      | LLM plan polishing     | +28.8pp AndroidWorld, competitive SOTA [2505.14141]
LLM Agent        | Code plan (LLM/few-shot) | Feedback adaptation | +3–5pp vs DEPS, 2–600× demo reduction [2305.16653]
Quadrotor Motion | Kinodynamic path     | B-spline + MPC + CBF   | 6.8 m/s in racing, 100% safe, 92% disturbance recov. [2403.12865]

The above table summarizes the planner and refiner concrete roles, along with headline empirical results across representative domains.

## 6. Limitations and Future Directions

- **No Polynomial-Time Guarantees:** Most Planner-Refiner settings inherit fundamental intractability, e.g., PSPACE-hardness for MR-TAMP or MAPF. Solution quality and speed derive from hierarchical decomposition and problem structure.
- **Local Minima and Completeness:** In plan rewriting and MAPF, local search can be trapped away from global optima; careful rule design or neighborhood selection is required for broad reachability [1106.0250, 2102.12331].
- **Representation Dependency:** Planner and refiner modules may require harmonization at interface boundaries (symbolic→geometric, EFSM→NL, parse→attention), which can introduce brittleness to incomplete models or noise.
- **Sample/Annotation Effort:** Language-based planner-refiner architectures may require curated exemplars; recent work leverages skill discovery and prompt optimization to shrink this overhead [2305.16653].
- **Extensions:** Integration of onboard perception, learning-based initial plan synthesis, more efficient constraint reasoning, and adaptation to partial observability or dynamic environments are active directions [2403.12865, 2305.16653].

## 7. Significance and Cross-Domain Influence

The Planner-Refiner architecture offers a highly general, theoretically grounded, and empirically robust methodology for scalable, high-quality decision-making and optimization across robotics, AI planning, agent systems, and multimodal alignment. Its characteristic modularity fosters transfer across domains: for example, the PbR pattern in symbolic planning inspired structure in multi-agent, language-guided, and even continuous control systems. Its influence continues to grow as demands for both rapid first-answer planning and sophisticated, domain-adaptive refinement rise in real-world and large-scale AI systems [2309.08897, 1106.0250, 2102.12331, 2505.14141, 2508.07330, 2305.16653, 2403.12865].

Source: https://www.emergentmind.com/topics/planner-refiner