Planner-Refiner Architecture

• Planner-Refiner is a two-stage framework that generates an initial feasible plan and refines it for higher fidelity and performance.
• It uses modular methods such as optimization, rule-based rewriting, and constraint satisfaction to enhance suboptimal solutions.
• Empirical evidence shows notable improvements in efficiency and robustness in robotics, multi-agent systems, vision-language alignment, and more.

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 (Sung et al., 2023, Qiu et al., 2024), multi-agent systems (Okumura et al., 2021), language-based agents (Sun et al., 2023, Mo et al., 20 May 2025), vision-language alignment (Tran et al., 10 Aug 2025), and general symbolic planning (Ambite et al., 2011).

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 (Sung et al., 2023).

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) (Ambite et al., 2011).

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) (Okumura et al., 2021).

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 (Tran et al., 10 Aug 2025).

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 (Sun et al., 2023, Mo et al., 20 May 2025).

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 (Qiu et al., 2024).

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 (Mo et al., 20 May 2025).
• 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 (Sung et al., 2023).
• 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 (Ambite et al., 2011).
• In multi-agent pathfinding, anytime operation is preserved, convergence is empirically fast, and monotonic cost reduction is guaranteed per-refinement (Okumura et al., 2021).
• 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 (Sun et al., 2023, Mo et al., 20 May 2025).
• In robotics, decomposition (A* to B-spline to model predictive contouring control) supports real-time, disturbance-tolerant, and safe trajectories at high speeds (Qiu et al., 2024).

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 (Sung et al., 2023)
PbR	Fast full plan	Local rewriting+search	≈1.1–1.2× optimal, anytime (Ambite et al., 2011)
MAPF	Suboptimal solution	Iterative local opt	Near-optimal (<2% gap), 1000+ agents (Okumura et al., 2021)
Vis-Lang Align	Parse query (NP/VP)	Space-time attention	+7–10pp vs SOTA on complex queries (Tran et al., 10 Aug 2025)
GUI Agent	EFSM path (LLM)	LLM plan polishing	+28.8pp AndroidWorld, competitive SOTA (Mo et al., 20 May 2025)
LLM Agent	Code plan (LLM/few-shot)	Feedback adaptation	+3–5pp vs DEPS, 2–600× demo reduction (Sun et al., 2023)
Quadrotor Motion	Kinodynamic path	B-spline + MPC + CBF	6.8 m/s in racing, 100% safe, 92% disturbance recov. (Qiu et al., 2024)

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 (Ambite et al., 2011, Okumura et al., 2021).
• 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 (Sun et al., 2023).
• 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 (Qiu et al., 2024, Sun et al., 2023).

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 (Sung et al., 2023, Ambite et al., 2011, Okumura et al., 2021, Mo et al., 20 May 2025, Tran et al., 10 Aug 2025, Sun et al., 2023, Qiu et al., 2024).