Planning LLM: Modular and Robust

• Planning LLM is a large language model designed to synthesize structured plans by decomposing complex tasks and enforcing domain constraints.
• The LLM-Modulo framework employs iterative feedback from modular critics to transform free text into validated, actionable plan formats.
• Empirical results on travel planning benchmarks show that modular planning systems significantly outperform direct prompting methods.

A Planning LLM is a LLM applied to tasks that require generating, refining, or assisting in the creation of structured plans—sequences of coordinated actions or decisions that lead from a defined initial state to a desired goal, often under domain-specific constraints. Unlike routine text generation, planning LLMs are evaluated by their effectiveness at decomposing multi-step tasks, managing dependencies, ensuring constraint satisfaction, and producing actionable solutions that are robust to real-world complexities. The current frontier in LLM-based planning involves modular and hybrid frameworks that meld LLMs’ expressive generative abilities with explicit verification, iterative refinement, task formalization, and integration of critics or symbolic solvers.

1. Motivation and Planning LLM Paradigms

Despite LLMs' capabilities in language understanding and basic stepwise reasoning, direct use of LLMs for complex planning—especially in domains demanding multi-step, constraint-rich logic (e.g., travel itinerary building, symbolic problem solving, or embodied agent control)—reveals critical limitations. Baseline prompting strategies such as Chain-of-Thought (CoT), ReAct, and Reflexion yield <1% accuracy on realistic travel planning benchmarks, far from human performance (Gundawar et al., 31 May 2024).

The LLM-Modulo framework addresses these weaknesses by not treating the LLM as an end-to-end black box but embedding it in an iterative, generate-and-test pipeline. This framework orchestrates the LLM as an "idea generator," tasking it with candidate plan synthesis. Each plan candidate is then scrutinized by a suite of external or LLM-powered critics (verifiers) that assess validity, constraint compliance, and plausibility. If errors or violations are detected, critics supply actionable feedback—so-called "backprompts"—that are incorporated in subsequent LLM generations, forming a closed-loop refinement cycle.

2. LLM-Modulo Pipeline and Agentic Roles

The LLM-Modulo architecture for planning is characterized by the following modular components:

• Prompt Generator: Prepares structured context, action schemas, constraint lists, and formatting requirements to the LLM.
• Plan Backboard and Reformatter: Receives the LLM’s candidate plan, converting it from natural language into a machine-interpretable schema (commonly JSON), often by using a dedicated LLM as a reformulator.
• Critics/Verifiers: Independently check candidate plans for correct format, satisfaction of hard constraints (e.g., budget, timing, resource allocation), and soft/commonsense requirements (e.g., diversity, completeness, logical continuity).
• Metacontroller: Aggregates feedback from all critics, manages iteration flow, and halts the process upon success or exhaustion of the iteration budget (typically capped at 10 rounds).
• Iterative Loop: Each iteration consists of LLM plan generation, conversion, multi-critic evaluation, and feedback-driven revision.

LLMs serve not just as plan generators, but as reformulators (translating free text to structure) and even as critic-generators—able to output code (e.g., a Python function to compute "total trip cost" or validate calendar overlaps) for automated evaluation modules (Gundawar et al., 31 May 2024).

3. Evaluation Methodology and Quantitative Results

The efficacy of planning LLMs is best quantified via benchmarks that stress multi-step reasoning under hard and soft constraints. A leading example is the TravelPlanning Benchmark [Xie et al., 2024], comprising 180 validation tasks that require LLMs to generate itineraries from unstructured language while satisfying a broad set of realistic requirements.

The principal evaluation metrics are:

• Delivery Rate: Fraction of attempts where any plan is output.
• Constraint Pass Rate: Micro- and macro-averages for both soft (commonsense) and hard (rule-based) constraints.
• Final Pass Rate (Success Rate): Proportion of plans that satisfy all required constraints:

$$\text{Final Pass Rate} = \frac{|\{x : x \in \mathcal{Q},\, \text{Plan}(x)\ \text{satisfies all constraints}\}|}{|\mathcal{Q}|}$$

• Ablation Analysis: Performance when only specific types of critics (format/hard/commonsense) are active.

Table summarizing core results (Gundawar et al., 31 May 2024):

Method / Model	Final Pass Rate (%)
Direct (GPT-3.5-Turbo)	0.0
Chain of Thought (GPT-3.5-Turbo)	0.0
ReAct (GPT-3.5-Turbo)	0.6
Reflexion (GPT-3.5-Turbo)	0.0
Direct (GPT-4-Turbo)	4.4
LLM-Modulo All	5.0
LLM-Modulo All	20.6

These results indicate that LLM-Modulo delivers a 4.6x lift in success rate with GPT-4-Turbo over the strongest non-modular baseline, and notably enables much weaker models (e.g., GPT-3.5-Turbo) to outperform direct planning attempts with stronger LLMs.

4. Composition and Composability of Critics

Critics in LLM-Modulo are modular and composable:

• Format Critics: Assess structural validity (e.g., correct JSON, field coverage, data type correctness).
• Hard Constraint Critics: Enforce strict, explicitly-defined requirements (e.g., budget, time windows, location feasibility, legislative adherence).
• Commonsense Critics: Capture qualitative and context-sensitive notions (e.g., logical completeness of plans, diversity of activities, avoidance of illogical sequences).

Empirical ablation demonstrates that combining critics yields higher pass rates than any single subset; using only hard or only format critics improves over baseline but is strictly dominated by the all-critics configuration.

5. Formalism, Prompts, and Modularity

The LLM-Modulo pipeline is heavily reliant on transparent interface schemas and explicit feedback to mediate between LLM outputs and automated critics:

• Schema Examples: Candidate plans are reformatted as structured objects (typically JSON), which are then validated programmatically.
• Prompting for Critic Extraction: LLMs are given domain schemas and prompted to output evaluation functions (e.g., "Given this itinerary JSON, write code to compute total trip cost or to check for double booking").

This reliance on explicit, modular schemas enables both rapid adaptation to new domains and clear traceability of planning failures, a significant advance over opaque direct-output LLM prompting.

6. Limitations, Open Challenges, and Broader Implications

While LLM-Modulo demonstrates substantial improvements over prior LLM-only planning paradigms, several limitations and open challenges persist:

• Upper Bound on Iterations: Most plans converge or are abandoned within 10 rounds, suggesting boundary conditions for practical use.
• Critic Design and Operators: Modular critics must be sufficiently expressive; missing or weak critics limit the effectiveness of the pipeline.
• Scaling: For more complex, combinatorial planning domains, the scalability of the interaction loop, critical generation, and plan refinement must be further studied.
• Domain Knowledge: While LLMs can often autonomously generate critic code, some domains may require domain expert design of evaluation functions.
• Generality: Results in the travel planning domain are strong, but further work is needed to generalize across logistical, scheduling, or embodied agent plans.

The LLM-Modulo framework moves LLMs from brittle, monolithic solvers towards agentic, modular planners—where the roles of generation, structuring, criticism, and iteration are decomposed to leverage both LLM flexibility and the rigor of explicit evaluation.

7. Relationship to Broader Planning LLM Research

LLM-Modulo exemplifies an emerging class of modular, neuro-symbolic planning systems for LLMs. It is directly responsive to major challenges identified in recent surveys (Wei et al., 16 Feb 2025, Cao et al., 26 May 2025)—notably, the tension between generality and constraint satisfaction, plan soundness, and real-world domain transfer. Its modular pipeline connects to trends in the fusion of LLMs with external verifiers, programmatic intermediate formats, and multi-role agentic architectures.

A key implication is that effective planning LLM systems will, in general, require:

• Iterative, feedback-based architectures rather than single-shot prompting.
• Explicit, inspectable intermediate plan formats.
• Composable, runtime-adaptable critics for various classes of constraints.
• Flexible LLM utilization beyond naive plan generation, to encompass plan reformulation, critic synthesis, and specification extraction.

In summary, the planning LLM—particularly in the LLM-Modulo formulation—is characterized by agentic modularity, robust constraint handling, explicit multi-role orchestration, and significant empirical performance gains on realistic planning benchmarks, especially when compared against naive or end-to-end LLM solutions.