---
title: 'LMPlan: Language-Model-Based Planning'
url: https://www.emergentmind.com/topics/lmplan
type: topic
---

# LMPlan: Language-Model-Based Planning

Searching arXiv for recent papers on LMPlan and closely related uses of the term.
arxiv_search(query="LMPlan planning large language models PDDL", max_results=10)
arxiv_search(query="\"Language Models For Generalised PDDL Planning\" LMPlan", max_results=10)
arxiv_search(query="2508.18507", max_results=5)
arxiv_search(query="\"Learning to Plan with Natural Language\"", max_results=5)
LMPlan denotes a family of language-model-based planning approaches in which a language model participates in transforming an initial state into a goal-reaching course of action. In the recent literature, the term is used in two distinct but related senses: as a broad label for LLM-based planning systems, and as the name of specific methods, notably a natural-language task-plan learner and a generalized PDDL planner that synthesizes programmatic policies. Across these uses, LMPlan sits at the intersection of symbolic planning, search, optimization, tool use, and executable policy synthesis, with recurring concerns around soundness, completeness, executability, generalization, and efficiency [2502.11221][2304.10464][2508.18507].

## 1. Terminology and scope

In the broadest sense, LMPlan refers to the use of large language models as planners: systems in which an LM proposes actions, decompositions, symbolic models, heuristics, or executable code that can transform an initial world state into a goal state. This reading appears explicitly in survey and systems papers that treat LMPlan as a general concept rather than a single architecture [2502.11221][2512.17062].

A narrower usage names particular methods. In "Learning to Plan with Natural Language" [2304.10464], LMPlan is a two-phase method that learns a reusable natural-language task plan from training errors and validation feedback, then injects that learned plan into test-time prompting. In "Language Models For Generalised PDDL Planning: Synthesising Sound and Programmatic Policies" [2508.18507], LMPlan is a planner that prompts language models to synthesize Python programs serving as generalized policies or value functions for PDDL domains.

This dual usage matters because it prevents a common misreading of the literature. LMPlan is not a single canonical algorithm. Depending on the paper, it may denote a prompt-time planner, a translator from natural language to PDDL or optimization code, an interactive tool-using planner, a policy synthesizer, or a domain-specific architecture such as symbolic-to-geometric task and motion planning for manipulation [2405.04215][2410.12112][2411.13826][2512.17062].

## 2. Formal planning model

A standard formalization used in the LMPlan literature defines a planning problem as $P = \langle S, A, T, s_0, G \rangle$, where $S$ is the state space, $A$ the action set, $T$ the transition function, $s_0$ the initial state, and $G$ a goal predicate. In STRIPS-style terms, each action has preconditions and add/delete effects, with state update given by $s_{t+1} = (s_t \setminus del(a)) \cup add(a)$. A plan $\pi = (a_1,\dots,a_T)$ is valid if successive applications of actions from $s_0$ terminate in a state satisfying $G$ [2502.11221].

The generalized-PDDL LMPlan paper uses an equivalent deterministic formulation, $P = \{S, A, f, G, s_I, c\}$, where $f : S \times A \to S \cup \{\bot\}$ is the transition function and $c$ is a cost function. Applicable actions at state $s$ are $A(s) = \{a \mid f(s,a) \neq \bot\}$, and a solution is a finite sequence of applicable actions reaching a goal state [2508.18507].

These formalizations support the metrics that recur throughout the literature. A prominent survey organizes evaluation around six criteria: completeness, executability, optimality, representation, generalization, and efficiency. Completeness asks whether a planner finds a solution when one exists and recognizes unsatisfiable tasks; executability measures whether produced plans respect action preconditions in the environment; optimality concerns plan cost or regret; representation concerns the fidelity of natural-language, symbolic, or programmatic encodings; generalization measures transfer to unseen domains or instances; efficiency covers tokens, wall-clock time, and inference cost [2502.11221].

In application-specific variants, the same template is lifted to richer state spaces. In symbolic-to-geometric manipulation, symbolic states are grounded predicates over objects, poses, and workspace relations, while each symbolic action must be mapped to a feasible geometric trajectory subject to kinematics, collision avoidance, and planner-specific constraints [2512.17062]. This suggests that LMPlan is best viewed as a layered planning interface rather than a commitment to a particular world model.

## 3. Architectural patterns in the literature

One major pattern uses LLMs directly at inference time, often with closed-loop interaction. REPL-Plan is exemplary: the model writes code line by line in an LLM-REPL, executes it, reads outputs and exceptions, spawns child REPLs when undefined functions are called, and uses variables, loops, functions, and tool calls to manage long-horizon planning. The resulting system is fully code-expressive and dynamic, combining deterministic execution with language-level reasoning for fuzzy subproblems [2411.13826].

A related but more formally grounded pattern equips the LLM with a live simulator or symbolic engine. PyPDDLEngine exposes PDDL planning operations through a Model Context Protocol interface so that the model can query the current state, query applicable actions, execute one action at a time, reset to the initial state, and validate complete plans. In this setup the LLM acts as an interactive search policy over a formal transition system rather than committing to a full plan in one shot [2603.06064].

A second pattern makes the LLM a translator or formalizer and delegates solving to a downstream formal engine. NL2Plan incrementally extracts types, hierarchies, action schemas, predicates, objects, initial states, and goals from minimal natural-language descriptions, constructs a PDDL domain and problem, validates them, and then calls a classical planner. LLMFP pushes the same idea further by having the model derive decision variables, constraints, and objectives, generate Python/Z3 programs from scratch, execute them, and self-repair missing constraints or faulty formulations [2405.04215][2410.12112].

A third pattern relocates most LM work to construction time. A reliability-focused synthesis argues for generating symbolic solvers, planning models, or policy code offline, verifying them, and then executing them at inference time with minimal or no further LLM calls. It groups such approaches into NL2Search, NL2PDDL, and NL2Policy, and frames the shift as a response to the unsoundness, incompleteness, and high cost of many single-shot or shallow-search hybrids [2605.21902].

## 4. Specific systems named “LMPlan”

The natural-language LMPlan of "Learning to Plan with Natural Language" represents a task plan as text comprising general step-by-step solutions and behavioral instructions. Its training loop collects errors produced under the current plan, prompts the LLM to propose multiple update candidates, validates each candidate on a held-out subset with a threshold $\delta = 1.0$, compresses surviving candidates to remove redundancies, and appends the best one to the plan. At test time, the learned plan is inserted into the prompt so that the model is instructed to follow the learned solutions step by step [2304.10464].

That system reports substantial accuracy gains across mathematical, causal, logical, symbolic, and combinatorial reasoning tasks. On the AMPS benchmark, zero-shot CoT averages rose to 66.6 versus 51.6 for Self-Plan; on MATH, zero-shot CoT average reached 29.8 versus 23.3 for Self-Plan; and on six non-math tasks, zero-shot average reached 66.0, with large gains in settings such as Last Letter Concatenation. The learned plans were also transferable across models, for example improving SayCan from 72.0 to 80.0 when a ChatGPT-learned plan was applied to GPT-4-32k [2304.10464].

The generalized-PDDL LMPlan of [2508.18507] is structurally different. It prompts a language model to synthesize Python classes that implement either a value function $h(s)$ for Greedy Best-First Search or a reactive policy $\pi(s) \in A(s)$. PDDL domains and problems are parsed, actions are grounded, and applicability is computed through SQLite-backed database-style queries over relational state representations. Runtime guards enforce applicability for policy rollout and replace heuristic outputs of $\infty$ with a large finite constant, enabling soundness theorems for policy rollout, value-function GBFS, and a combined two-queue GBFS.

Empirically, that LMPlan achieves unusually strong generalized-planning performance on ten IPC Learning Track domains. The policy-only variant solves $\Sigma 563$ test problems, exceeding LAMA’s $\Sigma 557$ and solving all 90 test problems in six domains. A portfolio that selects value function or policy per domain reaches $\Sigma 630$. The paper also reports a striking symbolic-renaming result: for value-function synthesis, replacing meaningful PDDL names with meaningless symbols slightly improves total coverage from $\Sigma 397$ to $\Sigma 406$, whereas policy synthesis is more brittle under such renaming [2508.18507].

Taken together, these two named LMPlan systems illustrate two different research directions. One treats planning as the learning of reusable natural-language guidance for downstream reasoning. The other treats planning as the synthesis of sound, executable programs over formal transition systems.

## 5. Domain-specific realizations of the LMPlan concept

In robotics manipulation, Lang2Manip operationalizes LMPlan as symbolic-to-geometric task and motion planning. An LLM is constrained to the symbolic action grammar $\{pick, place, move, push\}$, the environment state is textualized from Kautham’s internal geometry, the model emits a JSON action sequence, and each symbolic action is grounded into grasp selection, inverse kinematics, planner selection, and collision-free motion queries through Kautham and OMPL. On a Franka Emika Panda task, 20 trials with randomized object poses yielded an 85% task success rate and 92% motion-planning feasibility, with symbolic-plan correctness errors of about 10% [2512.17062].

In autonomous driving, LAP uses an LLM not to output controls directly but to classify scene complexity and recommend mode and speed adjustments for a hybrid planner switching framework. The text outputs are mapped to a mode variable $\beta \in \{0,1\}$ and a speed-shaping parameter $\gamma$, which are then consumed by tree-search MPC for fast driving or alternating-minimization full-shape planning for dense traffic. In a CARLA-based Macau Grand Prix environment, LAP reports lap time 269.13 s versus 265.65 s for the optimistic obstacle-free baseline, average speed 86.95 km/h, and peak 211 km/h; with retrieval-augmented generation, Gemini-2.0-Flash reached 97% precision in scene understanding versus 48% without RAG [2601.21876].

In participatory urban planning, the term LMPlan is used for a multi-agent framework in which a planner agent and 1,000 resident agents co-produce land-use plans through role-play, community discussion, and iterative revision. On two Beijing regions, one paper reports Satisfaction and Inclusion scores of 0.787 and 0.773 in HLG and 0.778 and 0.790 in DHM, while another closely related version reports 0.784 and 0.764 in HLG and 0.784 and 0.794 in DHM; both papers position the framework as outperforming human experts on need-aware metrics and remaining competitive on Service and Ecology [2402.17161][2402.01698].

In multi-robot temporal planning, PLANTOR integrates LLM-based knowledge-base generation with Prolog and MILP. The model produces a two-phase Prolog knowledge base, Prolog derives a total-order plan and causal enablers, MILP schedules actions under temporal and resource constraints, and the final STN is compiled into a Behavior Tree for ROS2 execution. The framework was validated in block-world and arch-building settings, including a real experiment with UR3e and UR5e arms [2502.19135].

In long-horizon embodied planning under uncertainty or partial observability, the LMPlan idea appears in several forms. LLaMAR uses a centralized plan–act–correct–verify loop over a textual memory and multimodal observations, achieving about 30% higher success rate than other state-of-the-art LM-based multi-agent planners on MAP-THOR and Search-and-Rescue tasks [2407.10031]. PlanU couples LLM-driven action proposals with MCTS over quantile return distributions and an Upper Confidence Bounds with Curiosity score, improving over RAP, LATS, and prompt-only baselines in Blocksworld, Overcooked, VirtualHome, TravelPlanner, and WebShop [2510.18442].

## 6. Reliability, efficiency, and open questions

A central tension in LMPlan research is between flexibility and formal reliability. Survey and synthesis papers repeatedly note that pure LLM planners and many bounded-search hybrids are unsound or incomplete, costly at inference time, and vulnerable to hallucinated feasibility or degraded performance on unseen tasks. This is the main rationale behind solver-backed, translator-based, and construction-time approaches that reuse symbolic search, PDDL planners, MILP, SMT, or executable policies [2502.11221][2605.21902].

Empirical evidence supports this caution. In agentic step-wise PDDL planning on 102 IPC Blocksworld instances, Fast Downward solves 85.3%, while direct and agentic LLM planning solve 63.7% and 66.7% respectively under a 180-second budget. The agentic improvement is only 3.0 percentage points and costs about $5.7\times$ more tokens per solution, leading the authors to argue that step-wise interaction helps substantially only when environmental feedback provides externally grounded progress signals rather than self-assessed state updates [2603.06064].

This has a practical implication for how LMPlan systems are engineered. The most robust variants tend to couple the LM to an external verifier, planner, optimizer, simulator, or executable programming environment. In such systems, the LM is strongest when used for decomposition, representation choice, knowledge extraction, symbolic grounding, policy synthesis, explanation, or repair, while correctness is enforced by formal semantics or grounded execution [2405.04215][2411.13826][2508.18507].

A second open question concerns what LMs are actually exploiting when they plan. The symbolic-renaming ablation in generalized PDDL planning is noteworthy because value-function synthesis sometimes improves when meaningful names such as `(at dog kitchen)` are replaced by meaningless symbols such as `(p2 o1 o3)`. The paper presents this as a challenge to explanations centered only on natural-language semantics or memorized solutions, and it suggests that structure-sensitive program synthesis may play a larger role than often assumed [2508.18507].

Overall, the literature portrays LMPlan not as a settled planner family but as a research program. Its most successful instantiations either learn reusable plans, synthesize executable solver components, or embed language models inside formally constrained planning stacks. The unresolved issues—soundness without heavy scaffolding, efficient handling of long horizons, planning under uncertainty, and the role of semantics versus structure—remain central to the field’s current trajectory [2502.11221][2605.21902].

Source: https://www.emergentmind.com/topics/lmplan