Toward Secure and Reliable PDDL Formalization of Large Language Models with Planner-in-the-Loop Feedback

What Happened

A new arXiv preprint (2606.29700) introduces a framework for improving how large language models (LLMs) formalize planning problems into the Planning Domain Definition Language (PDDL). The core innovation is a "planner-in-the-loop" feedback mechanism: instead of relying solely on an LLM to generate PDDL specifications from natural language descriptions, the system runs the generated domain and problem files through an actual planner. If the planner fails—due to syntax errors, logical inconsistencies, or unsolvable formulations—the error messages and planner outputs are fed back to the LLM for iterative refinement.

This addresses a persistent weakness in LLM-based planning: while LLMs can produce plausible-looking PDDL, they frequently introduce subtle errors that render the specification unexecutable or logically invalid. The paper's approach treats the planner not as a passive consumer of LLM output, but as an active validator that closes the loop between generation and execution.

Why It Matters

The significance lies in bridging two worlds that have historically operated in parallel. LLMs excel at understanding ambiguous natural language and generating structured outputs, but they lack the formal guarantees required for safety-critical planning tasks. Classical planners, conversely, provide rigorous verification but require precisely formatted inputs that are brittle to produce manually.

For autonomous systems—whether in robotics, supply chain logistics, or military decision-support—the cost of a flawed plan specification can be catastrophic. A PDDL file that looks correct but contains an unsolvable goal, a missing action precondition, or a type mismatch can lead to execution failures that are difficult to diagnose post-hoc. The planner-in-the-loop approach provides a concrete, automated quality gate that catches these failures before they propagate into real-world actions.

This work also addresses a scalability challenge. As LLMs are increasingly deployed to generate plans from high-level human instructions, the volume of plan specifications will far exceed what human experts can manually verify. Automated validation through planner feedback is a practical necessity, not a luxury.

Implications for AI Practitioners

For engineers building LLM-powered planning systems, this research suggests a clear architectural pattern: never trust an LLM's structured output without a validation step that exercises the output in its intended runtime environment. The planner-in-the-loop concept generalizes beyond PDDL to any domain where LLMs generate formal specifications—database queries, configuration files, API calls, or robot control sequences.

Practitioners should also note the feedback loop design. The paper's approach uses the planner's own error messages as natural language prompts for the LLM to self-correct. This is more efficient than retraining or fine-tuning, and it leverages the LLM's existing capabilities for debugging and iterative refinement. However, it also implies that the planner must produce informative error messages—a design consideration that many existing planners neglect.

The approach does introduce latency and computational overhead, since each iteration requires a full planner invocation. For real-time applications, practitioners may need to limit the number of feedback rounds or pre-validate common patterns.

Key Takeaways

• Planner-in-the-loop validation provides a practical method for catching PDDL formalization errors that LLMs frequently introduce, using the planner itself as an automated quality gate.
• Iterative refinement from planner feedback leverages LLMs' existing self-correction capabilities without requiring retraining, but depends on planners producing human-readable error messages.
• Architectural pattern generalizes beyond planning: any LLM-generated formal specification should be validated by executing it in its target environment before deployment.
• Trade-off between accuracy and latency must be managed, as multiple planner invocations per specification increase computational cost and response time.