One Demo Is All It Takes: Planning Domain Derivation with LLMs from A Single Demonstration
Authors: Jinbang Huang
Yixin Xiao
Zhanguang Zhang
Mark Coates
Jianye HAO
Yingxue Zhang
Venue: ICLR 2026 Poster (2026)
Keywords: Planning Domain Inference
PDDL
Robot Task Planning
Task and Motion Planning
LLMs for Planning
Embodied AI
Primary area: applications to robotics, autonomy, planning
TL;DR: Using LLMs and physical simulation to derive planning domains with minimal manual domain initialization, enhancing LLM's performance in long-horizon task planning.

Abstract: Pre-trained large language models (LLMs) show promise for robotic task planning but often struggle to guarantee correctness in long-horizon problems. Task and motion planning (TAMP) addresses this by grounding symbolic plans in low-level execution, yet it relies heavily on manually engineered planning domains. To improve long-horizon planning reliability and reduce human intervention, we present Planning Domain Derivation with LLMs (PDDLLM), a framework that automatically induces symbolic predicates and actions directly from demonstration trajectories by combining LLM reasoning with physical simulation roll-outs. Unlike prior domain-inference methods that rely on partially predefined or language descriptions of planning domains, PDDLLM constructs domains with minimal manual domain initialization and automatically integrates them with motion planners to produce executable plans, enhancing long-horizon planning automation. Across 1,200 tasks in nine environments, PDDLLM outperforms six LLM-based planning baselines, achieving at least 20% higher success rates, reduced token costs, and successful deployment on multiple physical robot platforms.

Published as a conference paper at ICLR 2026
ONE DEMO Is ALL IT TAKES: PLANNING DOMAIN DERIVATION WITH LLMS FROM A SINGLE DEMON- STRATION
Jinbang Huang', Yixin Xiao', Zhanguang Zhang', Mark Coates", Jianye Hao', Yingxue Zhang'
Huawei Noah's 's Ark Lab, McGill University
ABSTRACT
Pre-trained large language models (LLMs) show promise for robotic task plan- ning but often struggle to guarantee correctness in long-horizon problems. Task and motion planning (TAMP) addresses this by grounding symbolic plans in low- level execution, yet it relies heavily on manually engineered planning domains. To improve long- horizon planning reliability and reduce human intervention, we present Planning Domain Derivation with LLMs (PDDLLM), a framework that automatically induces symbolic predicates and actions directly from demonstration trajectories by combining I.I.M reasoning with physical simulation roll-outs. Un- like prior domain- inferrncceee methods that rely partially predefined or language descriptions of planning domains, PDDLLM constructs domains with minimal manual domain initialization and automatically integrates them with motion plan- ners to produce executable plans, enhancing long-horizon planning automation. Across 1,200 tasks in nine environments. PDDLLM outperforms six LLM-based planning baselines, achieving at least 20% higher success rates, reduced token costs, and successful deployment on multiple physical robot platforms.
INTRODUCTION
Robotic planning remains challenging in complex scenarios that require abstract, long-horizon reasoning. Large language models (LLMs) demonstrate strong generalization in this domain but often struggle with temporal dependencies in extended tasks (Huang et al. 2022a b). Task and motion planning (TAMP) frameworks provide robustness in long-horizon reasoning by integrating high-level symbolic reasoning with low-level motion planning. However, they face two major limitations: (i) planning domains, expressed in symbolic planning languages such as PDDL (McDermott
1998).
are difficult to ground in complex geometric information, and (ii) these domains are labor-intensive to
manually construct (Garrett et al. 2020, 202 Khodeir al.] 2023 Silver et al. (02T). Recent vision- language-action models have vanced the first challenge by improving geometric grounding through semantic action instructions, but they pay limited attention to long-horizon reasoning (Black et al.)
2024 Kim al. 2024 Zitkovich et al. [023] Li al., 2024 Team al. 2024). Complementarily.
our work focuses on solving the second challenge by reducing the human effort required for domain construction, thereby enabling automated and scalable hong-horizon reasoning.
Existing Coomain-generatee methods typically rely on predesigned elements (predicates or actions) to complete domain (Silver et al. 2023 Kumar al. 2023), where manual predesign remains critical and often depends on curated training data (Huang et al. (025). LLM--bssed approaches also demand extensive natural-languaae deseriptions PDDL domains and careful prompt engineering (Guan ct al. 2023; Oswald et al. 2024). Mcanwhile, recent advances in world-model learning show that
LLMs can serve as compact explainer and reasoner for robot behavior and object relations (Guan et al. 2023 Zhao et al. 2023 Liang et al. 2024] Tang et al. 2024). Motivated by this, we propose to combine LLM reasoning with physical simulation to generate planning domains, eliminating reliance on manual predesign, curated training data, and detailed textual descriptions.
Correspondence to: Linbang.huang @ @h-perterrscoommm (ww.:raacocmmmnagaannnanmomm
(zhanguang.rhagg yingxue.zhang! @huawei.com

---

Published as a conference paper at ICLR 2026
We introduce PDDLLM, an LLM- framework for automated planning domain construction that requires minimal pre-design and no extensive human-proveen provided descriptions. From a single demonstration, the model generate both predicates and actions in one-shot fashion, yielding an executable planning domain. Moreover, PDDLLM automates integration with low-level motion planners, further reducing the need for manual intervention. Our method targets long-horizon planning problems, aligning with the scope of TAMP studies. Managing action sequences and task structures is essential for these tasks such household activities and puzzle solving. The main contributions of this paper are:
An algorithm that combines LLMs and physical simulation to automatically generate a human-interpretablle planning domain from single demonstration.
A Logical Constraint Adapter (LoCA) ) that systematically interfaces the generated domain with low-level motion planners.
An extensive evaluation on over 1,200 tasks in nine environments, demonstrating superior long-horizon planning performance and more efficient token usage than state-of-the-art baselines, with successful deployment three physical robot platforms.
RELATED WORK
Task planning with pre-trained large models With the advent of pre-trained large models (LMs), the use of LLMs and vision language models (VLMs) has significantly advanced the performance of task planners (Huang et al. 2022b Wang al. 2024 Chen et al. 2024b Li et al. 2023). Although many studies have demonstrated the generalization capabilities of L.M-hased task planners, they often
lack robustness and struggle with long-horizon tasks that require complex reasoning (Wang et al.) 10224Sermanne et al. 2024 Driess et al.) 2023 Ahn et al. [022: Huang et al. 2022a). To address this limitation, recent research has explored guiding task planners with LM-derived heuristics to accelerate informed search. These approaches integrate symbolic search with LMs to accelerate task planning and reduce search complexity. Notable efforts include heuristics for prioritizing feasible
states (Zhao et al. 2023), ,, ranking feasible actions (Yang et al. 2025 Meng et al. 2024 Hu et al.)
2023 Zhao et al.] 2023), and pruning search trees (Silver et al. 2024). However, a major limitation
of these methods lies in their reliance on manually constructed symbolic planning domains to build
search trees, which imposes additional development overhead and reduces flexibility.
Learning planning domains A recent line of research aims infer the planning domain directly from human demonstrations, environment interactions, or natural language. However, these ap- proaches often depend partially fully predefined symbolic predicates and actions as well as extensive training dataset (Silver et al. 2023 Kumar et al. 22023 Huang et al. 2025 Wong et al. 2023 Liu al. 2024). Some recent studies have explored leveraging LMs for domain generation.
primarily by extending manually defined domains with additional predicates and actions (Liang et al.
2024; Athalye et al., 2024 Byrnes et al., 2025). The approaches proposed by Guan et al. (2023);
Han et al. (2024) generates planning domains requiring prompts containing human- crafted planning examples or intense manual Beedback.Another line of research investigates generating and refining planning domains through environmental feedback. (Liang et al. [2024] Zhu et al. (025). Moreover, many studies assume that logical actions have pre-designed mnotion-level primitive skills (Kumar et al., 2023; Huang et al.) 2025| Athalyy et al. [2024] Han et al.) 2024),, requiring lubor-intensive alignment between planning domains and low-level motion planners. PDDLLM addresses this limitation by automatically grounding symbolic actions into motion constraints, thereby reducing manual effort and enhancing scalability and autonomy.
3 PRELIMINARIES
PDDL is a standard formal language used to specify planning problems. The object set represents the environment's objects, whose continuous state S, such as pose, color, and size, can be queried via a perception function I: I + S. The PDDL domain D = (P, .A) describes the general rules of the environment, consisting of set of logical predicates P and a set of logical actions A. logical predicate E P specifies either intrinsic properties of an object o or relations between objects (e.g., (cooked ?01), (on ?01 ?02)) ). Each predicate is evaluated by binary classifier
2

---

Published as a conference paper at ICLR 2026
the continuous state, returning true false. A symbolic description of the environment X' can be obtained by grounding P across S (i.e. x X). logical action a E A consists of precondition Prre (p..P2....> and action's ''s effect Pefs .fi.P.....). The precondition represents a set of predicates that must be satisfied for the action to be executed, while the action's effect describes the change of the resultant state upon action completion. Logical actions define the logical state transitions X²(t) at)) + x(++1) Thus, any planning problem (S(imit), (((inat)) can be formulated as a logical planning problem Q (O,D, (imii)) x((fnnat)), which is solved by symbolic planner to produce task plan ( aa1), ................................ ((())...((?_.) a(T-1) PDDLSolver Each logical action a must then be integrated with corresponding motion planning skills to generate continuous robotic actions à for execution.
PROBLEM STATEMENT
Our system solves a new long-horizon planning problem given an expert demonstration trajectory Tdemo and its associated task description demoo The trajectory Tdemo is sequence of continuous environment states ((0) ,S(1)
while Tdemo is short natural language phrase describing the task.
Following prior work (Silver et al.) 2023] Kumar et al. 2023 Huang et al. 2025), the robot the sole acting agent during data collection.
Given a new planning problem, PDDLLM derives a PDDL domain from (Tdemo: Tdemo) which generates sequence of symbolic actions the task plan. LoCA, component within PDDLLM, interfaces the task plan with an off-the-shelf motion planner, which produces executable robot trajectories. Formally, the problem can be expressed as:
a (0) ((1))
( = Motion Planner(PDDDLLN)) new
(fnit) S(goal) new
Tdemo; Tdemo)
where (init) and Snew
((goat) define the initial and goal states of the new problem, denotes the task plan length, and (0:L) indicates executable robot trajectory.
METHODOLOGY
Figure presents an overview of the PDDLLM framework. With Tdemo and Tdemo as inputs, PDDLLM constructs relevant predicate library through predicate imagination and generates an action library via action invention. Ultimately, these predicate and action libraries are compiled into an executable PDDL planning domain, automatically interfaced with motion planners via LoCA. In the following sections, we provide detailed explanation of each step in the framework.
5.1 PDDL DOMAIN GENERATION
Given a human demonstration and its task description, our system combines simulated physical interactions with LLM- based reasoning to generate an executable PDDL planning domain through predicate imagination and action invention. Simulation verifies the physical feasibility that LLMs alone cannot reliably enforce, while the LLM abstracts these grounded interactions into logical predicates and actions. This combination enables robust pipeline for planning-domall construction.
5.1.1 PREDICATE IMAGINATION
Predicate imagination refers to the process of summarizing simulated object relation roll-outs into meaningful predicates. The process consists of two stages: Stage generates first-order predicates and Stage further derives the higher-order predicates from the first-order predicates.
Stage 1. In this stage, PDDLLM generates first-order predicates, which directly describe the physical properties or relations of the objects (e.g.. (is_on 201 ?02), (smaller 201 ?02) ), by summarizing simulated object interactions using an LLM.
Definition 1 (Feature Space). The feature space is defined such as position, orientation, size, and color, that fully characterize the state of each object in the environment.
of continuous state variables,
3

---

Published as a conference paper at ICLR 2026
Human demonstration
Predicute Imagination
LoCA
Physical Simulation
New Tasks
Pradicate Library
Ploase creaie prodicate in PDD/ yuntor...
Action Inveation
Transition
Planning Domain
Action Library
The robot is naching cabess
Please create an action for tie grvinn traviitinn..
Figure I: Overview the proposed framework. (I) Human demonstrations, in the form of manipula- tion trajectories, and the corresponding task descriptions, serve input. Implementation details is shown in Section B. (2) PDDLLM initiates thousands of parallel simulations, using the resulting roll-outs and rich physics- thysies-based feedback guide the LLM in summarizing them into meaningful predicates, and returns predicate library annotated with each predicate's relevance to the current task. (3) Actions are invented by LLM that summarizes logical state transition patterns from the demonstration, which is grounded into logical states using the imagined predicates. (4) The predicates and actions are compiled into a planning domain, which automatically interfaced with motion planning algorithm by the Logical Constrain Adapter (LoCA) to solve new tasks.
Following Definition [ the feature space is defined set of variables, such Cartesian coordinates (v, y, 2) for object positions and RGB values (r, g, b) for colors. The feature space is bounded by real-world constraints. Object states uniformly sampled across this space span a diverse range of object-object and object-environmen verification process. First, is evaluated for physical feasibility using a physical simulator, which serves physical knowledge base to capture complex dynamics beyond the reasoning capacity of LLMs. Only physically valid states are retained.
interactions. Each sampled state undergoes a two-step
However, the full continuous feature space is highly scattered, making it difficult for the LLM to detect consistent patterns or infer meaningful numeric thresholds. Thus, we discretize space into coherent sub-regions that group similar states together, enabling the LLM to extract stable relational patterns. Additionally, these aub-feature-spac boundaries provide physically grounded constraints that allow the motion planner to reliably evaluate predicate truth values during planning.
feature
Next, PDDLLM partitions the feature space into finite collection of subspaces. The range of each feature is divided into intervals, with the length of each interval being hyperparameter. The intersections of these intervals specify the subspaces. Each object state can be mapped into one of the subspaces. Each subspace is analyzed to determine whether it contains feasible object states, as verified through simulation in the previous verification step. If so, simulation roll-out summaries generated as prompts following a predefined scene-description template. Prompt generation is automated as it only requires the replacement of some keywords (such as "position" with "color") and the specification of interval boundaries. An LLM is then prompted summarize subspaces into meaningful predicates and select those relevant to the task. The subspace boundaries serve as predicate physical constraints, enabling the classification of whether predicate holds true. Figure 2 illustrates an example of predicate generation for positional relations between objects.
Stage 2. Although the first-order predicates already capture all necessary features the environment, higher-order predicates are essential for representing more complex relations and improving planning efficiency. Thus, we systematically derive higher-order predicates by combining first-order predicates with logical operators and quantifiers. We focus using negation operator, together with the quanti- fiers "for all" (V) and "there exists" (3), as they are empirically proven effective in robotics by prior work (Curtis et al. 2022; Silver al. 2023). These components combined in all possible valid ways to form richer logical expressions that provide stronger guidance during planning. For example, (is__n on
202) be negated to produce (not_is is_on 701 ?02). . When combined with
4

---

Published as a conference paper at ICLR 2026
Predicate Imagination
Simulation Verification
Prompt LLM
Predicate Constraints
Rollout Summary. There are two okjects in the envzonment. whose posilions (tu and (a - Fell uy. the aatis
Predicate I Library
paramelers: [ol, o2)
pl: [nome: "is on'
Oite Predicatie on ou, Poy.... Higher Prodicate:
ubject, properties
moo 5 th. Its - Vil Up Un 2, 2u,
(1.4), *g]]
Uy Yal i by. the
physical constraint:
-is (?os, ?0g). vo,, un [7oy, Toyl...
[ix -xg Mgg. ...))
b.Action Invention
Logical Constrain A daption (LoCA)
alina Trajectury Logical Space
Action Library:
Constrained Motion plaminng
Bufd -, qumt (140 sna dur (-00) 22)--
sactiog slack
fultiak Laolding, Robot
(petuneess (Pol to
precondttoo fond (talding fol
PVoljects -ebove Cabe 01
(Volgects whowe ha0l)
wfiee fied (nst (talding 7ol.
oz 7020
li Culle
"nottviteers -loow 7x20))
(robjects -above, Cube GJ
(rooleeds -toiday,
(votjoats -holding, RoboC
O
Figure 2: a. This example illustrates the imagination of predicates for relative object positions. Let be configurable variable for each dimension. Object poses are sampled and simulated, with infeasible cases filtered out by the simulation feedback. Feasible subspaces are provided to the LLM generate first-order predicates with their corresponding physical constraints. Higher-order predicates can be further derived using logical operators (e.g.. "not", "for all") from first-order predicates. Diverse predicate examples are provided in Section B.9 b. This example shows how the Stack action is invented. Continuous states are grounded into logical states using the imagined predicates, where the state transition represents the logical action. By prompting the LLM with the pair of the current state and the next state after the transition, we obtain the PDDL definition of the action Stack. c. The integration of actions with the motion planner is handled automatically by LoCA, which retrieves the physical constraints associated with each first-order predicate in the action effect set Pesy and applies these constraints for motion planning.
the universal quantifier, this further yields (V_o1_not is is_on____o_oooooo______oooso on 201 ?02), , meaning that for any 01 in the environment, (is_onn ?01 ?o2) is false. This indicates that object 02 is top.
5.1.2 ACTION INVENTION
After constructing the predicate library, the human demonstration Tdemo can be mapped into the
Logic logical space as demoo by grounding all relevant predicates at each time step. The logical state transitions within llgic ddemo signify the execution of actions. An advantage of learning actions in the logical space that simplifies pattern recognition by focusing on moments of logical state transitions, effectively transforming long trajectories into concise logical representations. For instance, logic the continuous manipulation trajectory Tdemo in Figure 2 contains over 1000 time steps while Temmo is reduced to merely 2 steps. Logical state transitions are extracted from pre-and-post-chee post-change states and presented to the LLM prompts. After experimenting with various prompt structures, found this direct, structured method to be the most effective. A concrete example of action invention for Stack is elaborated in Figure b.
5.1.3 PARALLEI PROMPTING WITH FEEDBACK
To avoid planning domain generation failure due to the random nature LLMs, we adopt parallel prompting strategy with domain execution feedback. Specifically, multiple candidate PDDL domains are generated from the same demonstration via prompting the LLM multiple times. If a generated domain encounters run-time error (syntax, incomplete domain, fail to reach goals..), then this planning domain eliminated from the candidates. more than one planning domain is successfully produced, then majority vote would be initiated using the LLM to choose the best one. Empirically, we find that when the number of parallel prompts exceeds five, the correctness of the final domain converges stable level. Examples of the parallel prompting procedure are shown in Section B.7
5

---

Published as a conference paper at ICLR 2026
5.1.4 HYPERPARAMETER SELECTION
For each continuous feature f. we initialize its discretization scale uy using the smallest non-zero observed difference dman of that feature among all relevant objects. This provides conservative upper bound on the required uy: it ensures that the learned predicates remain expressive enough to capture distinctions for all objects. During ML-M-based predicate summarization, the model is allowed to refine the initial discretization hyperparameter u by either merging or subdividing sub-feature intervals. Specifically, the LLM can merge intervals that are semantically uninformative for the task into single broader region, and subdivide intervals in feature regions where finer distinctions are necessary. Consequently, even if the initial choice of u is imperfect, the refinement process enables the LLM to recover the task-relevant granularity and generate predicates that remain both expressive and compact.
5.2 AUTOMATIC INTERFACING WITH MOTION PLANNER
Combining the PDDL planning domain with symbolic solvers yields task plan (0)), a()), (TT-1) The next step is to establish an interface between each logical action and the low-level motion planner.
In PDDILM, this interfacing is fully automated through the Logical Constraint Adapter (LoCA). Prior approaches relied on manually encoding logical actions as mathematical constraints for motion planning (Toussaint] 2015). LoCA automates and generalizes this process by directly retrieving the physical constraints associated with the first-order predicates in an action's effect set Pett. These constraints, expressed as mathematical inequalities, are sequentially applied the motion planner, ensuring that the required predicates are satisfied once the action is executed. In this way, LoCA automatically transforms each logical action into a standard constrained motion planning problem. As result, the generated trajectory is guaranteed to align with the semantic meaning of the action, as illustrated Figure c.. This eliminates the need for manually engineered interfaces or predefined motion-planning skills, thereby streamlining the integration between symbolic planning and low-level control.
Additionally, our framework is also compatible with recent advances such as vision-languuge-action (VLA) models by directly using logical actions as prompts. Experiments Section [ demon- strate PDDLLM's ability to automatically integrate with both traditional and learning- based motion planning.
6 EXPERIMENTS AND BASELINES
Building on evaluation practices in TAMP, we consider tasks with concrete conditions such as object
position, orientation, size, and color (Silver al. 2023 Garrett et al. 2020 Kumar al. 2023 Liang
et al. 2024 Huang et al. (0225). We structure our experiments along three dimensions, Task Diversity. Task Complexity, and Knowledge Transferability, whose definitions are provided in Section 0.
with task details described in Section Our experiments are conducted in PyBullet Simulation (Coumans Bai 2016 2016-202I), with the symbolic solver from PDDLStream (Garrett et al., (2020) and
the motion planning algorithm from PyBullet- BBullet-Planning (Garrett et al., 2015 Garrett 2018). We use
GPT-4o (OpenAl 2023), but our method is not tied to this backhone. All experiments use parallel prompts and set u dmin; full ablations are provided in Section B.15 and Section B.
By default, PDDLLM learns planning domaín from a single corresponding demonstration per task. To assess its ability to integrate cross-task knowledge, we also evaluated settings where only demonstrations from simpler related tasks were provided for more complex one. Specifically, for the rearrangement, the model received only demonstrations of both stacking and unstacking, while for the bridge building, it was given only demonstrations of both stacking and alignment.
6.1 BASELINES AND ABLATIONS
We implement six baselines and ablation of PDDLLM comprehensively evaluate method. GPT-4o is used as the default LLM unless otherwise specified, and the motion planning algorithm is kept the same for all methods. The complete details are provided in Section B.2

---

Published as a conference paper at ICLR 2026
LLMTAMP. o1-TAMP. RI-TAMP: LLM- --seedddd task and motion planning (LLMTAMP)
inspired by Huang et al. (2022a): Li et al. (2022), which use LLMs for task planning, with language description of planning task input. The task execution demonstration, same as those used in PDDLLM, was provided in the form of natural language in prompt. In addition GPT-4o, reasoning LLMs, OpenAl's s ol (OpenAl 2024) and Deepseek's R1 (DeepSeek Al 2025), are used as backbones for O1-TAMP and RI-TAMP, respectively.
LLMTAMP-FF: Following the method by Huang et al. (022b); Chen et al. (2024a),
LLMTAMP-FE extends LLMTAMP with failure feedback loop.
LLMTAMP-ER. Following Wang al. 2024), LLMTAMP-FR extends failure detection by providing specific failure reasons to guide replanning with the LLM.
Expert Design: The expert design baseline uses expert-crafted planning domains with symbolic solvers. Expert-designed domains are refined from PDDLLM-derived domains by an expert.
In addition to the six baselines, we include an ablation of our method, RuleAsMem, which uses the generated PDDL domain as contextual memory for LLM task planners, replacing symbolic solvers.
Robot planning is required to be real- timm in robot deployment, imposing constraints on the planning time allowance (Gammell et al., 2013 Garrett et al. 2015 2020). In our experiment, a uniform planning time limit of 50 seconds is applied to all planning problems and methods. We measure performance using the planning success rate, as other studies (Huang al. 2025)] [Silver al.) 2023; Kumar et al. (023). The planning time and token cost are used to measure the planning cost (Zhong al. 2024p. Three parallel runs were conducted to compute the mean and standard error for the planning success rate.
Table 1: Planning success rate (%) across tasks for all methods (time limit 50 s). The best results are highlighted in bold. Expert is excluded from the comparison, as it requires additional manual effort and serves upper bound.
Method
Expert
LLMTAMP
LLMTAMP-FF
LLMTAMP-FR
RuleAsMem
PDDLLM
Stack
98.5 1 0.8
1.37.44.
70.8
6.12
85.5 2.9
97.5 1 1.6
Unstack
100
89.4
9.
2.3
88.4111
97.7 1: 0.7
Color Classification
100 0.0
18.1 1.5
36.4+
49.0
88.7
100 0.0
Alignment
100
31.1
5.70
40.0
9..0
100 0.0
Parts Assembly
98.9 0.6
3
4..3
95.0
100 : 0.0
Rearrange
73.3 1
5.6
1.0
17.
11.8
1.1
64.3 1 0.7
Burger Cooking
100 0.0
27.8
50.0
48.6 6.9
27
91.7 + 4,8
Bridge Building
100 100 1
43.3 1 3.3
5..8
5..7
20.0 1.00
87.2 1 4,3
Tower of Hanoi
100 1: 0.0
14.3
0.0
14.3
1..3
14.3 1.30
100 1: 0.0
Overall
95.7 0.1
35.7 0.5
48.6 0.8
69.9 0.7
93.3 +
RESULTS
Through the experiments, we aim to answer the following research questions: (1) How does PDDLLM perform relative other LLM-based planners? (2) Can PDDLLM generalize to unseen, more complex tasks? (3) Does PDDLLM derive high-quality domains with performance comparable to expert designs? (4) How does PDDLLM's token cost compare to other LLM-based planners? (5) How does PDDLLM recover from errors such as by suboptimal demonstrations?
Q1. Performance comparison to baselines: Table presents the planning success rate of all evaluated methods across all tasks, measured with a 50-second time limit. PDDLLM shows clear advantages in planning efficiency and generalizability over baseline methods. While LLM-based baselines perform competitively in simpler tasks like stacking and unstacking, their performance drops sharply in complex tasks such as rearrangement, burger cooking, bridge building, and Tower Hanoi. In contrast, PDDLLM maintains strong performance across all task categories, achieving improvement in overall planning success rate compared to the best LLM- based planner baseline (i.e., ILMTAMP- FF.). Even the ablated variant of PDDLLM, RuleAsMem. outperforms the L.Le-based
40%
7

---

Published as a conference paper at ICLR 2026
1.0
0.8
Success rate.
0.8
Success Rate
0.6
0.4
0.4
POOLIM (Durs)
POOLLM LLMTAMP
LLNTAN FFF
LEMTAMP-FR
0.0
PFR
10
15 20
0.0
20.0
40.0
60.0
80.0
Number of objects involved in the tasks
Time (seconds)
Figure 3: (left) Planning success rate trend across increasing object counts. (right) Overall planning
success rate under varying time limits.
planners at least 17.4% in overall success rate. Compared PDDLLM, RuleAsMem exhibits less stability. It performs well in simpler tasks but struggles in more complex ones, suggesting the LLMs struggle to understand complex domains. In addition the results evaluated with a 50-second time window, we also report the overall success rates of the main methods across varying time limits. As shown Figure righht), PDDLLM consistently outperforms the baseline methods and demonstrates superior planning performance across all time limits. Notably, it reaches performance saturation the fastest, highlighting superior time efficiency among all evaluated approaches.
We further compare PDDLLM's planning ability with more powerful reasoning LLMs (OpenAI-ol and DeepSeek-R1) in Table 2 While reasoning-bar based models exhibit strong planning capabilities, their high computational cost prevents them from completing within the 50-second window. To suffi- ciently compare the planning capabilities, we extend the time limit to 500 seconds and evaluate them on the most challenging tasks. Although o1 o1-TAMP and R1-TAMP show remarkable improvement compared to GPT-4o- based LLMTAMP, they remain less robust in long-horizon planning and fail to match PDDLLM's performance. In contrast, method, relying solely GPT-4o, consistently achieves higher success rates across complex tasks. Detailed time costs for reasoning models are provided in Section B.6
The experimental results highlight PDDLLM's ability to handle increasing complexity in both planning and domain derivation, consistently outperforming baseline methods. In terms planning complexity, as shown Figure left), PDDLLM maintains robust planning performance task complexity grows, achieving high success rates even in scenarios involving up to 20 objects. As shown Table performance degradation is observed in more challenging tasks such rearrangement, where longer action sequences required and there are more complex motion constraints. From the perspective of domain derivation complexity, PDDLLM remains effective even tasks demanding the generation of over 100 predicates. However, success rates drop in the most complex domains, such as bridge building, primarily due to missing supporting predicates, More details of the generalization of each task are provided in section B.5
Q2. Generalization:
PDDLLM demonstrates a strong ability to integrate knowledge across demonstrations, The modular nature of PDDL action syntax allows the easy transfer actions learned from different demonstrations among domains. Despite receiving only one example each for stacking and unstacking, successfully combines "stack" action the "unstack" action to solve rearrangement tasks. Similarly, the bridge building domain, PDDLLM successfully combines the "align" action and the "stack" action using one demonstration of cube alignment and one stacking. The high success rate these tasks in Table I underscores the robustness of the derived planning domains.
We evaluate the quality of planning domains generated by PDDLLM by comparing the percentage of missing redundant predicates(actions and the planning success rate against expert-designed domains. The full definition of missing or redundant can be found in Section B. None of the generated domains of missing and redundant predicates for the four evaluated tasks, measured against numan-designe domains. The number of parallel prompts is fixed at 10. and each task is evaluated over three runs; the reported values are the averages across these runs. These results show that PDDLLM produces high-quality domains with minimal emors, in complex scenarios. While few predicates may be
Q3. Domain Quality:
missing actions. Table reports the percentage
8

---

Published as a conference paper at ICLR 2026
absent, the overall logical structure remains sound, as reflected in the high overall planning success rate of 93.3% shown in Table [] closely matching the performance of expert-crafted domains.
Q4. Token efficiency: We compare the token efficiency of our method against LLM-bascd baselines on the three most complex tasks, as shown in T Although the GPT-4o-based LLMTAMP incurs lower total token costs, it performs poorly across all three tasks. Compared to 01-TAMP and R TAMP, PDDLLM uses significantly fewer tokens while consistently achieving better performance. These results also underscore the challenge of deploying reasoning LLMs on real robot systems for long-term use due to high token consumption. Unlike other LLM-based planners. PDDLLM spends tokens only during domain derivation; execution is handled by PDDL solver with no additional token cost. This makes it well suited for long-tern term deployments that repeatedly perform similar tasks.
Table 2: Comparison of planning success rate (%) and token cost (k) between PDDLLM and LLMTAMP and the reasoning LLM variants. The best results are shown in bold, and the second-best results are underlined.
Success Rate (%)
Token Cost (k)
Task
PDDLLM
LLMTAMP
01-TAMP
R1-TAMP
PDDLLM
LLMTAMP
01-TAMP
RI-TAMP
Rearrangemnnt
1.1
5.6 1.0
+
40.0 +
Tower of Hanoi
100.0 +
0..
33.3
14.3
529
Bridge Building
87.2 = 4.3
3.3
51.7
40.0 -
270
Overall
80.5 0.5
13.9 0.9
61.5 1.3
35.9 +: 3.1
415
99
666
725
Domain refinement occur by adding demonstrations refining language guidance. To evaluate how PDDLLM corrects an imprecise domain, we conducted bridge- building experiments that require coordinated picking, stacking, and alignment skills, using demon- strations that were intentionally masked or perturbed. With only a picking demo, PDDLLM had no evidence that stacking or alignment mattered, so their predicates were overlooked or collapsed into vague forms. As additional demonstrations were provided, PDDLLM progressively reconstructed the missing structure and sharpened constraints. Table shows success rates rising as the missing information is supplied, demonstrating effective domain repair. We also injected noisy, unrelated unstacking demo; it briefly appeared in the domain but was later pruned due to low usage frequency.
QS. Domain Correction:
In addition to supplying more demonstrations, providing clearer task descriptions also improves predicate precision by offering richer contextual cues about the task objective. We include an experiment validating this effect in Section B.18
Table 3: Percentage of missing or redun- Table 4: Bridge- buigge- success rate (%) under varying demonstration conditions.
dant predicates and actions across tasks.
Task
Missing
Redundant
Class
Demonstration Type
Success Rate (%) f
Stack
4.2%
8.3%
Missing
pick
0.0 + 0.0
Burger Cooking
22.2%
3.7%
Missing
pick & stack
20.0 + 0.0
Bridge Building
22.2%
3.7%
Complete
pick & stack & align
86.7 3.8
Tower of Hanoi
0.0%
14.3%
Redundant
pick & stack & align & unstack
83.3 1: 3.3
REAL ROBOT DEPLOYMENT
We validate PDDLLM on real robots to demonstrate cross- cross-platform deployability. The system is tested on the Agilex Piper, Franka Panda, and the UR5e, using ArUco markers for pose estimation and ROS2 for control. All platforms successfully complete tasks, including table-top stacking. bridge building, burger cooking, and the Tower of Hannoi through direct deployment of PDDLLM (details in Section B.I.. We also evaluated how PDDLLM integrates with leamed skills such as VLA on a tabletop stacking task with a URSe. In this experiment logical actions serve directly as prompts condition policies,, bypassing explicit motion constraints. The real-robot experiment with VLA (details in Section 1.33) demonstrates PDDLLM's compatibility with both classical and based control.

---

Published as a conference paper at ICLR 2026
a. Tower of Hannoi
b. Bridge Building
Burger
d. Stack
Figure 4: Real-robot experiment three different platforms
LIMITATION
A limitation of PDDLLM is its occasional omission of highly complex predicates, which can reduce problem-solving efficiency and lead lower success rates in more difficult tasks such as Burger Cooking and Bridge Building (Table []. For example, in bridge building, the system may attempt to assemble the surface before the base complete, making subsequent placements infeasible and requiring backtracking. Expert-designed domains address this by introducing predicate call_base_fii finifiiii.e shed) to enforce correct ordering. While the absence of such predicates does not directly cause planning failure, it slows down planning as the planner must perform additional feasibility checks and degrade performance under a fixed time budget. Recent work has attempted to mitigate this issue by refining planning domains through interactive or snvironment-feeddacle methods (Liang et al.] 2024, Huang et al.) 2025 Zhu et al. 2025). As with many TAMP systems, perception errors and the representation of complex dynamics and geometries, such deformable objects and fluids, remain challenging for PDDLLM. Thus, we demonstrate that PDDLLM can be combined with approaches designed for such settings, including VL.--bssed manipulation methods.
10 FUTURE WORKS
There few future work directions found meaningful to approach. (1) Integrating perception to enable domain derivation from raw sensory inputs. Symbolic planning struggles to ground raw visual inputs into logical representations. Learning visual features directly would allow the system to derive predicates from sensor data, improving robustness to perception noise and reducing reliance on perception engineering. (2) Enabling direct interaction with the environment allows the system to obtain feedback that helps complete missing predicates, improve domain quality, reduce reliance on simulation, and better capture complex real-world dynamics. (3) Partial observability environments that requires active explore to acquire missing information.
11 CONCLUSION
This paper presents PDDLLM, the first approach in the field to generate a complete planning domain from scratch, without relying on any predefined predicates or actions. By extracting logical struc- tures directly from pre-trained LLMs, PDDLLM autonomously derives both predicates and actions, enabling fully automated domain construction. Evaluated across a wide range of environments, PDDLLM demonstrates high quality in domain derivation and strong generalizability across diverse task categories. Moreover, when integrated with the LoCA framework, PDDILMM fully automates the integration between the PDDL. planning domain and the low-level motion planner. This level of automation significantly improves usability and positions the framework as an adaptable and scalable solution for robotic planning and decision-making Compared to existing methods, PDDLLM outper- forms other LLM-based baselines and closely matches the performance of expert-designed planning domains, particularly in complex and long horizon planning scenarios.
10

---

Published as a conference paper at ICLR 2026
REPRODUCIBILITY STATEMENT
To facilitate reproduction of our results, we provide clear references to the relevant sections of the paper. The overall planning pipeline is described Section 4 The extraction of the PDDL domain from demonstrations is illustrated in Figure D with additional details provided in Section B. The procedure for predicate imagination and action invention discussed in the Section || where we also outline the prompt templates and prompting strategies in greater detail in Section B.3 Finally,
the LoCA framework is described comprehensively in Section 5.2 and experiment details shown in Section g and Section B.
ETHICS STATEMENT
We affirm our commitment to the principles laid out in the ICLR Code of Ethics, including honesty, fairness, transparency, and avoidance of harm. The human demonstrations collected not contain identifying information. Our research does not use sensitive personal private data. We have carefully documented our methodology, data sources, and limitations to promote reproducibility and accountability. We no foreseeable misuses of the methods results discussed in this work, but we remain alert to potential downstream impacts and encourage continued scrutiny in the broader research community.

---

Published as a conference paper at ICLR 2026
REFERENCES
Michael Ahn, Anthony Brohan, Noah Brown, Yevgen Chebotar, Omar Cortes, Byron David, Chelsea Finn, Chuyuan Fu, Keerthana Gopalakrishnan, Karol Hausman, Alex Herzog, Daniel Ho, al. Do as i can and not as say: Grounding language in robotic affordances. arXiv preprint arXiv:2204.01691, 2022.
Ashay Athalye, Nishanth Kumar, Tom Silver, Yichao Liang, Jiuguang Wang, Tomás Lozano-Pére Pérez, and Leslie Pack Kaelbling. From pixels to predicates: Learning symbolic world models via pretrained vision-language models. arXiv preprint 2tw.:::2:01000009966 2024.
Kevin Black, Noah Brown, Danny Driess, Adnan Esmail, Michael Equi, Chelsea Finn, Niccolo Fusai, Lachy Groom, Karol Hausman, Brian Ichter, et al. тo: A vision sasionnlaguuag--cttion flow model for general robot control. arXiv preprint arXiv:2410.24164, 2024.
Walker Byrees, Miroslav Bogdanovic, Avi Balakirsky, Stephen Balakirsky, and Animesh Garg. Climb: Language guided continual learning for task planning with iterative model building. In 2025 IEEE International Conference on Robotics and Automation (ICRA). IEFF, 2025.
Yongchao Chen, Jacob Arkin, Charles Dawson, Yang Zhang, Nicholas Roy, and Chuchu Fan. Autotamp: Autoregressive task and motion planning with llms as translators and checkers. In 2024 IEEE International conference on robotics and automation (ICRA). IEEE, 2024a.
Yongchao Chen, Jacob Arkin, Yilun Hao, Yang Zhang. Nicholas Roy, and Chuchu Fan. PRompt optimization in multi-step tasks (PROMST): Integrating human feedback and heuristic-based sampling. In Proc. Conf. Empirical Methods in Natural Language Processing, 2024b.
Erwin Coumans and Yunfei Bai. Pybullet, python module for physics simulation for games, robotics and machine learning.
org. 2016-2021.
Aidan Curtis, Tom Silver, Joshua B. Tenenbaum, Tomás Lozano-Pérez, and Leslie Kaelbling. Dis- covering state and action abstractions for generalized task and motion planning. In Proc. AAAI Conf. on Artificial Intelligence, 2022.
DeepSeek-Al. Deepseek-rl: Incentivizing reasoning capability in Ilms via reinforcement learning. arXiv preprint arXiv:2501.12944. 2025.
Danny Driess, F Xia, Mehdi S M Sajjadi. Corey Lynch, Aakanksha Chowdhery, Brian Ichter, Ayzaan Wahid, Jonathan Tompson, Q Vuong, Tianhe Yu, Wenlong Huang, Yevgen Chebotar, P Sermanet, Daniel Duckworth, S Levine, Vincent Vanhoucke, Karol Hausman, Marc Toussaint, Klaus Greff, Andy Zeng, Igor Mordatch, and Peter R Florence. P-I.M-E: An embodied multimodal language model. In Proc. Int. Conf. on Machine Learning, 2023.
Jonathan D Gammell, Siddhartha S Srinivasa, and Timothy D Barfoot Batch informed trees (bit*): Sampling- based optimal planning via the heuristically guided search of implicit random geometric graphs. In 2015 IEEE international conference on robotics and automation (ICRA). IEEE, 2015.
Caelan Reed
Garrett.
Pybullet planning.
https://pyyL..or//prrr/
pybulles pybullett-paaningg/ 2018
Caelan Reed Garrett, Tomás Lozano-Péree and Leslie Pack Kaelbling. Backward-forwee search for manipulation planning. In Proc. IEEE/RSJ Int. Conf. on Intelligent Robots and Systems, 2015.
Caclan Reed Garrett, Tomás Lozano-Pérez, and Leslie Pack Kaelbling. PDDLStream: Integrating symbolic planners and blackbox samplers via optimistic adaptive planning. Proc. Int. Conf. Autom. Plan. Sched., 2020.
Caelan Reed Garrett, Rohan Chitnis, Rachel Holladay, Beomjoon Kim, Tom Silver, Leslie Pack Kaelbling, and Tomás Lozano-Péres Integrated task and motion planning. Annual Review of Control, Robotics, and Autonomous Systems, 4(1):265-293, May 2021.
Lin Guan, Karthik Valmeekam, Sarath Sreedharan, and Subbarao Kambhampati. Leveraging pre- trained large language models to construct and utilize world models for model-based task planning. In Proc. Ady. Neural Inf. Proc. Systems, 2023.
12

---

Published as a conference paper at ICLR 2026
Muzhi Han, Yifeng Zhu, Song-Chun Zhu, Ying Nian Wu, and Yuke Zhu. Interpret: Interactive predicate learning from language feedback for generalizable task planning. In Robotics: Science and Systems (RSS), 2024.
Mengkang Hu, Yao Mu, Xinmiao Yu, Mingyu Ding, Shiguang Wu, Wenqi Shao, Qiguang Chen, Bin Wang, Yu Qiao, and Ping Luo. Tree-plane Tree-planner: Efficient close-loop task planning with large language models. arXiv preprint 2tt.::3311.088833 2023.
Jinbang Huang, Allen Tao, Rozilyn Marco, Miroslav Bogdanovic, Jonathan Kelly, and Florian Shkurti. Automated planning domain inference for task and motion planning. In 2025 IEEE International Conference Robotics and Automation (ICRA). IEEE, 2025.
Wenlong Huang, Pieter Abbeel, Deepak Pathak, and Igor Mordatch. Language models as zero-shot planners: Extracting actionable knowledge for embodied agents. In Proc. Int. Conf. on Machine Learning, 2022a.
Wenlong Huang, Fei Xia, Ted Xiao, Harris Chan, Jacky Liang, Pete Florence, Andy Zeng, Jonathan Tompson, Igor Mordatch, Yevgen Chebotar, Pierre Sermanet, Tomas Jackson, Noah Brown, Linda Luu, Sergey Levine, Karol Hausman, and brian ichter. Inner monologue: Embodied reasoning through planning with language models. In Proc. Conf. on Robot Learning, 2022b.
Leslie Pack Kaelbling and Tomás Lozano-Pérer Hierarchical task and motion planning in the now. In 2011 IEEE International Conference on Robotics and Automation (ICRA). IEEE, 2011.
Kei Kase, Chris Paxton, Hammad Mazhar, Tetsuya Ogata, and Dieter Fox. Transferable task execution from pixels through deep planning domain learning. 2020 IEEE International Conference on Robotics and Automation (ICRA), 2020.
Mohamed Khodeir, Ben Agro, and Florian Shkurti. Learning to search in task and motion planning with streams. IEEE Robotics and Automation Letters, 2023.
Moo Jin Kim, Karl Pertsch, Siddharth Karamcheti, Ted Xiao, Ashwin Balakrishna, Suraj Nair, Rafael Rafailov, Ethan Foster, Grace Lam, Pannag Sanketi, et al. Openvla: An open-source vision-language-action model. arXiv preprint arXivv2406.09246, 2024.
Nishanth Kumar, Willie McClinton, Rohan Chitnis, Tom Silver, Tomás Lozano- Pérez, and Leslie Pack Kaelbling. Learning efficient abstract planning models that choose what to predict. In Proc. Conf. on Robot Learning, 2023.
Boyi Li, Philipp Wu, Picter Abbeel, and Jitendra Malik. Interactive task planning with language models. In Proc. 2nd Workshop on Language and Robot Learning, 2023.
Qixiu Li, Yaobo Liang, Zeyu Wang, Lin Luo, Xi Chen, Mozheng Liao, Fangyun Wei, Yu Deng, Sicheng Xu, Yizhong Zhang, al. Cogact: A foundational vision-language-action model for synergizing cognition and action in robotic manipulation. arXiv preprint arXiv:2411.19650 2024.
Shuang Li, Xavier Puig, Chris Paxton, Yilun Du, Clinton Wang, Linxi Fan, Tao Chen, De-An Huang, Ekin Akyürek, Anima Anandkumar, Jacob Andreas, Igor Mordatch, Antonio Torralba, and Yuke Zhu. Pre-trained language models for interactive decision meakiig.-mmking.... In Proc. Adv. Neural Inf. Proc. Systems, 2022.
Yichao Liang, Nishanth Kumar, Hao Tang, Adrian Weller, Joshua B Tenenbaum, Tom Silver, João F Henriques, and Kevin Ellis. VisualPredicator: Learning abstract world models with neuro-symbolic predicates for robot planning. arXiv preprint arXiv:2410.23156 2024.
Bo Liu, Yuqian Jiang, Xiaohan Zhang, Qiang Liu, Shiqi Zhang, Joydeep Biswas, and Peter Stone. LLM+P: Empowering large language models with optimal planning proficiency. arXiv preprint arXiv:2304.
1477, 11477 2023.
Weiyu Liu, Neil Nie, Ruohan Zhang, Jiayuan Mao, and Jiajun Wu. Learning compositional behaviors from demonstration and language. In Proceedings of The 8th Conference on Robot Learning. 2024.
13

---

Published as a conference paper at ICLR 2026
Drew McDermott, Malik Ghallab, Adele E. Howe, Craig A. Knoblock, Ashwin Ram, Manuela M. Veloso, Daniel S. Weld, and David E. Wilkins. Pddl-the planning domain definition language. 1998.
Silin Meng, Yiwei Wang, Cheng- Yang, Nanyun Peng, and Kai- Wei Chang. LLM-a*: Large language model enhanced incremental heuristic search on path planning. In Findings of the Assoc. for Comput. Linguistics: EMNLP 2024, 2024.
OpenAI. GPT-4 technical report. arXiv preprint arXiv:2303.08772, 2023.
OpenAl. OpenAl ol system card. arXiv preprint arXiv:2412.16722) 2024.
James Oswald, Kavitha Srinivas, Harsha Kokel, Junkyu Lee, Michael Katz, and Shirin Sohrabi. Large language models as planning domain generators. In Proc. Int. Conf. on Automated Planning and Scheduling, 2024.
Pierre Sermanet, Tianli Ding, Jeffrey Zhao, Fei Xia, Debidatta Dwibedi, Keerthana Gopalakrishnan, Christine Chan, Gabriel Dulac-Aroldd Sharath Maddineni, Nikhil Joshi, et al. Robovqa: Multimodal long-horizon reasoning for robotics. In 2024 IEEE International Conference on Robotics and Automation (ICRA). IEEE, 2024.
Tom Silver, Rohan Chitnis, Aidan Curtis, Joshua B. Tenenbaum, Tomas Lozano-Perez, and Leslie Pack Kaelbling. Planning with learned object importance in large problem instances using graph neural networks. In Proc. AAAI Conf. on Artificial Intelligence, 2021.
Tom Silver, Rohan Chitnis, Nishanth Kumar, Willie McClinton, Tomás Lozano-Pérez, Leslic Kael- bling, and Joshua B Tenenbaum. Predicate invention for bilevel planning. In Proc. AAAI Conf. on Artificial Intelligence, 2023.
Tom Silver, Soham Dan, Kavitha Srinivas, Joshua B Tenenbaum, Leslie Kaelbling, and Michael Katz. Generalized planning in pddl domains with pretrained large language models. In Proc. AAAI Conf. Artificial Intelligence, 2024.
Hao Tang, Darren Key, and Kevin Ellis. Worldcoder, a model-based Ilm agent: Building world models by writing code and interacting with the environment. Proc. Adv. Neural Inf. Proc. Systems, 2024.
Octo Model Team et al. Octo: An open-source generalist robot policy. In Robotics: Science and Systems (RSS), 2024.
Marc Toussaint. Logic-geometrie programming: an optimization-based approach to combined task and motion planning. In Proc. Int. Joint Conf. on Artificial Intelligence, 2015.
Shu Wang, Muzhi Han, Ziyuan Jiao, Zeyu Zhang, Yingnian Wu, Song-Chun Zhu, and Hangxin Liu. Llm3: Large language model-based task and motion planning with motion failure reasoning. In Proc. JEEE/RSJ Int. Conf. on Intelligent Robots and Systems, 2024.
Lionel Wong, Jiayuan Mao, Pratyusha Sharma, Zachary S Siegel, Jiahai Feng, Noa Korneev, Joshua Tenenbaum, and Jacob Andreas. Learning adaptive planning representations with natural language guidance. arXiv preprint arXiv:2312.08566 2023.
Yaqi Xie, Chen Yu, Tongyao Zhu, Jinbin Bai, Ze Gong, and Harold Soh. Translating natural language to planning goals with large-language models. arXiv preprint arXiv:2302.05128, 2023.
Zhutian Yang, Caelan Garrett, Dieter Fox, Tomás Lozano-Pérez, and Leslie Pack Kaelbling- Guiding long-horizon task and motion planning with vision language models. In 2025 IEEE International Conference on Robotics and Automation (ICRA). IEEE, 2025.
Zirui Zhao, Wee Sun Lee, and David Hsu. Large language models as commonsense knowledge for large-scale task planning. In Proc. Adv. Neural Inf. Proc. Systems, 2023.
Tianyang Zhong, Zhengliang Liu. Yi Pan, et al. Evaluation of openai ol: Opportunities and challenges of agi. arXiv preprint arXiv:2409.1 18486, 2024.
14

---

Published as a conference paper at ICLR 2026
Wang Bill Zhu, Miaosen Chai, Ishika Singh, Robin Jia, and Jesse Thomason. PSALM-V: V: Automating symbolic planning in interactive visual environments with large language models. arXiv preprint arXiv:2506.20097, 2025.
Brianna Zitkovich, Tianhe Yu, Sichun Xu, Peng Xu, Ted Xiao, Fei Xia, Jialin Wu, Paul Wohlhart, Stefan Welker, Ayzaan Wahid, et al. Rt-2: Vision-language-action models transfer web knowledge to robotic control. In Proceedings of The 7th Conference on Robot Learning. 2023.
15

---

Published as a conference paper at ICLR 2026
A
THE USE OF LARGE LANGUAGE MODELS (LLMS)
This paper evaluates LLMs within the robotics domain, where LLMs serve as the testing target of our method. Beyond this role, LLMs were used grammar-checking and text-polishing tools to improve readability (e.g., grammar, clarity, and style). They were not involved in the ideation, experimental design, analysis, interpretation of results, and did not contribute the scientific content. The authors take full responsibility for the entirety of the work presented.
B APPENDIX
B.1 REAL ROBOT EXPERIMENT
Ten runs each real robot experiment shown in Section are performed. The success rates of real-world deployment on different robot platforms are shown as below:
Table 5: Real-world success rate across tasks.
Metric
Tower of Hanol (Franka)
Bridge Building (Franka)
Burger (Piper)
Table-top Stacking (UR5e)
Success Rate
9/10
8/10
7/10
7/10
B.1.1
FRANKA PANDA ARM
Figure 5: Franka Panda Arm building bridge
16

---

Published as a conference paper at ICLR 2026
Figure 6: Franka Panda Arm solving the Tower of Hannoi puzzle
17

---

Published as a conference paper at ICLR 2026
B.1.2 AGILEX PIPER ARM
Figure 7: Agilex Piper Arm stacking cubes
18

---

Published as a conference paper at ICLR 2026
Figure 8: Agilex Piper Arm making burgers
19

---

Published as a conference paper at ICLR 2026
B.1.3 VLA EXPERIMENT WITH URSE
Figure 9: UR5e Arm Stacking Tabletop Objects
Experiment with the vision-language-action model is conducted using m0 model (Black et al. 2024), finetuned on 200 real-world pick and place trajectories. The resulting policy serves as the action module within our pipeline and is invoked by the PDDLLM planning system. In this setup, PDDLLM generates a high-level task plan, while the execution each logical action in the plan is carried out directly by the PiO policy. Importantly, the VLA experiment demonstrates the flexibility of our framework: the action execution layer can be implemented with either a classical motion planner learning-based policy, depending on the task requirements.
20

---

Published as a conference paper at ICLR 2026
B.2 BASELINE IMPLEMENTATION DETAILS
LLMTAMP: LLM-based task and motion planning (LLMTAMP) builds on methods from (Huang
al. 2022a Li et al. 2022), which use pre-trained LLMs for task planning. We formulate the planning problem em as a natural language description. Human demonstrations are interpreted as action sequences required accomplish the task. The LLM then generates high-level actions to achieve the goal, which are refined into motion plans using predefined skills.
LLMTAMP-FES LLMTAMP-FE. following the method by (Huang et al. 2022b Chen al. 2024a), extends LLMTAMP with a failure feedback loop. Upon execution failure, the system feeds the failure signal to the LLM to regenerate the task plan, repeating until success or the time limit reached.
LLMTAMP-FR Following Wang et al. (2024), LLMTAMP-FH extends failure detection by provid- ing specific failure reasons to guide replanning with the I.M.M We design a reasoner that generates detailed explanations for plan failures and incorporates them into the prompt as feedback. The LLM performs failure reasoning and then regenerates the plan accordingly.
The expert design baseline uses expert-crafted planning domains to evaluate how closely PDDLLM-generate domains approach human-level performance. To highlight the readability and customizability of PDDLLM, these expert-designed domains initialized with PDDLLM- generated outputs, which are then analyzed and refined by TAMP expert into ground truth domains.
Expert Design:
o1-TAMP and R1-TAMP: As reasoning models have demonstrated superior performance in many tasks (Zhong et al. 2024), we ablate the LLM in LLMTAMP to compare the planning performance of state-of-the-art reasoning LLMs with method. Specifically, we evaluate OpenAl's ol (OpenAI 2024) and Deepseek's 's RI (DeepSeek-A] 2025) as the reasoning backbones.
RuleAsMem: RuleAsMem is an ablation of PDDLLM that treats the generated PDDL domain as contextual memory, rather than using it with a symbolic planner. While prior work focuses on translating language into logical representations (Liu al. 2023) Xie et al., 2023), RuleAsMem directly integrates logical planning rules into the LLM prompt to solve new tasks, Each task is defined by initial and goal states, using the imagined predicates, along with a human demonstration in the form of PDDL task plan as prompts.
21

---

Published as a conference paper at ICLR 2026
B.3
PROMPT TEMPLATE
B.3.1 PREDICATE IMAGINATION
Template
There are objects in the environment, whose feature name are feature value and feature value In dimension 1, we know feature subspace range in dimension In dimension 2. we know feature subspace range dimension Plelase create predicate PDDL synlux describe this relation and classify if is related to the current lask description. Please relurn the result in the following format: predicate, relevance.
Example of object position relation
Prompt: There are two objects in the environment, whose positions are (X1)y1) and (x). In the horizontal direction, |x; X21 In the vertical direction, Y1 Y2 2u. Please create a predicate in PDDL syntax to describe this relation and classify if it is related to the task of stacking cubes together. Please return the result in the following format: predicate, relevance.
LLM: is (s_on?? 0₁ ?zz ?,.00z ), related.
Example of color relation
Prompt: There are two objects the environment, whose colors are (r, gr, b,) and (T2, 82, b2). In the red channel, Ini - r2l s u. In the green channel, Ig - gzl S u. In the blue channel, lb, b2l u. Please create predicate in PDDL syntax to describe this relation and classify if it is related to the task of stacking cubes together. Please return the result in the following format: predicate, relevance.
LLM: similar similar_color(? 02 02 unrelated.
Example of size relation
Prompt: There are two objects the environment, whose size are (w,, (w,,4,h,) and (W2, l2, h2). the width, 0 < W₂ - W2 S u. the length, < 1 S u. In the height, 0 < h, - h2 I u. Please create a predicate related to the task of stacking cubes together. Please return the result in the following format: predicate, relevance.
PDDL syntax describe this relation and
classify
LLM: larger_thand th o, 22), related.
Note: Here, u is a variable determined by feature subspace range length, which depends on the user input.
22

---

Published as a conference paper at ICLR 2026
B.3.2 ACTION INVENTION
Template
Current state: The logical state before action execution
Next shate:The logical state ofter the action execulion
Can you give this transition an action name to summarize and describe what happened. Please follow Planning Domain Definition Language syntax.
Example for inventing 'Pick'
Prompt:
The current state of the environment is:
(Vobjects-on -aboee, ol), (is on, ol o2), (Vobjects -holding, robot) After one action exccution, the resulting state of the environment is: (holding, o1, robot), (Vobjects mabove, o2)
Can you name this logical action summarize and describe what happened? Please follow Planning Domain Definition Language syntax and return together with action parameters, preconditions, and effects.
LLM:
:action pick
sparameters (?ol ?o2 ?r)
:precondition (and (is_on ?o1 ?o2) (Vobjects aaovv 2o1) (Vobjects holding, ?r)) :effect (and (not (is on ?ol ?o2)) (not (Vobjects -holding, ?r) (Vobjects aboove, ?o2) (holding, ?o1,9r) (not (Vobjects -above, o1)))
Example for inventing 'Place"
Prompt:
The current state of the environment is:
(holding, o1, robot) (Vobjects -above, o2)
After one action execution, the resulting state of the environment is: (Vobjects aaove, ol) (Vobjects -above, o2) (Vobjects -holding, -holdicts-holding robot)
Can you name this logical action to summarize and describe what happened? Please follow Planning Domain Definition Language syntax and return together with action parameters, preconditions, and effects.
LLM:
:action place
:parameters (?ol ?r)
:precondition (and (holding, ?o1,?r) :effect (and (not (holding, ?o1,?r) (Vobjects -above ?ol) (Vobjects -holding, ?r))
23

---

Published as a conference paper at ICLR 2026
B.3.3 LLMTAMP BASELINE
Part Initialization:
Imagine you are robot arm operator; you need to generate a sequence of actions to achieve the given goal. Here are the logical actions you can choose from: list of actions choose from
Part Human demonstrations:
Here examples for you learn:
example of input and output of the system
Part 3. New planning problem:
Now you are given a new input planning problem as the following: The initial state and the goal of the problem be solved Choose sequence of actions accomplish this task, and return the action sequence following the example output provided.
We integrate parts 1, 2, and 3 into complete prompt for the LLM to generate task plans.
Example for stacking problem
Prompt: Imagine you are robot arm operator; you need to generate sequence of actions to achieve the given goal. Here are the logical actions you can choose from: stack(upper box, lower box, robot), pick(upper box, table, robot).
Here are some examples for you to leam:
robot. Object 1 is table. Object 2 is box. Object is a box. Object 4 is box. Initially, the robot is not holding anything, Object is on table. Object is on table. Object 4 is on table. Object 2 is the topmost object. Object 3 is the topmost object. Object 4 is the topmost object. In the goal, Ojject 2 is above Object 3. Object is above object 4. Object is on Object 1. Object 2 is the topmost object. The robot is not holding anything,
Example input: Object
Example Output: pick(3, 1, 0), s3ack(3, 4, 0), pick(2, 1, 0), stack(2, 0).
Now you are given new planning problem the following: Object 0 robot. Object 1 is table. Object is box. Object 3 is box. Object 4 is box. Initially, Object 2 is on the table. Object 3 is on the table. Object 4 is on the table. Object 2 is the topmost object. Object is the topmost object. Object 4 is the topmost object. The robot is not holding anything. In the goal, Object is above object 3. Object 4 is above object 2. Object 3 is on Object 1. Object 4 is the topmost object. The robot not holding anything. Choose a sequence actions accomplish this task, and return the action sequence following the example output provided.
LLM: pick(2, 1, 0), stack(2, 3, 0), pick(4, 0), stack 2, 0).
24

---

Published as a conference paper at ICLR 2026
B.3.4 LLMTAMP+FAILUE FEEDBACK BASELINE
LLMTAMP+Failue Feedback extends LLMTAMP with failure feedback loop. Upon execution failure, the system feeds the failure signal to the LLM for replanning. Thus, the initial prompts of this baseline, part 1, 2, and 3, are the same the LLMTAMP prompt. However, there failure summarization. Integrating part 1-4 gives the full prompt.
Part Failure feedback:
Your plan failed in execution, please generate a different one. Only return the sequence of logical actions following the format of example output.
Example for stacking problem
Prompt: Imagine you are robot arm operator, you need to generate a sequence of actions to achieve the given goal. Here are the logical actions you can choose from: (pperr box, lower box, robot), pick(upper box, table, robot).
Here are some examples for you leam:
Example input: Object is a robot. Object is a table. Object 2 box. Object 3 is box. Object 4 box. Initially, the robot is not holding anything. Object 2 is on table. Object is on table. Object 4 is table. Object 2 is the topmost object. Object 3 is the topmost object. Object 4 is the topmost object. In the goal, Object is above Object 3. Object is above object 4. Object 4 is Object 1. Object 2 is the topmost object The robot is not holding anything.
Example Output: pick(3, 1, 0), s3ack(33, 4, 0), pick(2, 1, 0), stack(2, 3, 0).
Now you are given a new planning problem as the following: Object 0 is a robot. Object table. Object 2 is a box. Object is a box. Object Object is on the table. Object is on the table. Object 4 is on the table. Object 2 is the topmost object. Object 3 is the topmost object. Object is the topmost object. The robot is not holding anything. In the goal, Object 2 is above object 3. Object is above object 2. Object 3 is Object 1. Object 4 is the topmost object The robot is not holding anything. Choose sequence of actions accomplish this task, and return the action sequence following the example output provided.
box. Initially,
LLM: pick(4, 1, 0), stack(4, 2, 0), pick(2, 1, 0), stack(2, 3, 0).
Prompt: Your plan failed in execution, please generate a different one. Only retum the sequence of logical actions following the format of example output.
LLM: pick(2, 1, 0), stack(2, 3, 0), pick(4, 4, 1, 0), stack(4, 2, 0).
25

---

Published as a conference paper at ICLR 2026
B.3.5 LLMTAMP+FAILUE REASONING BASELINE
LLMTAMP + Failure Reasoning further extends failure detection by providing specific failure reasons to guide replanning with the LLM. Part 1, 2, and are the same as the LLMTAMP prompt. Integrating part 1-5 gives the full prompt.
Part 4. Failure Reasoning:
Your plan failed in execution, please generate a different one. This may involve sample new plans or reorder the last plan. Please generate output step-by-step. which includes your reasoning for the failure of the last plan. Answer the questions: (i) what the cause of the failure of the last plan? (ü) do you see similar mistakes in other steps in the plan? Here are the failure reasons: failure reasons
Part Replan:
Now, based on your above failure reasoning for (i) and (ii), generate a new task plan to solve the original planning problem. Only return the sequence of logical actions following the format of example output.
Example for stacking problem
Prompt: Imagine you a robot operator; you need to generate sequence of actions to achieve the given goal. Here are the logical actions you can choose from: stack(upped box, lower box, robot), pick(upper box, table, robot).
Here are some examples for you to learn:
Example imput: Object is rbot Object 1 table. Object 2 box. Object is box. Object 4 is a box. Initially, the robot not holding anything. Object 2 is on table. Object 3 is on table. Object 4 is table. Object 2 is the topmost object. Object 3 is the topmost object. above object 4. Object 4 is on Object 1. Object 2 is the topmost object. The robot is not holding anything.
Object 4 is the topmost object. the goal, Object above Object 3. Object
Example Output: pick(3, 1, 0), stack(3, 4, 0), pick(2, 1, 0), stack(2, 3, 0).
Now you are given a new planning problem as the following: Object is a robot. Object is table. Object 2 is box. Object 3 is box. Object 4 is box. Initially, Object 2 is on the table. Object is on the table. Object is on the table. Object 2 the topmost object Object is the topmost object. Object 4 is the topmost object. The robot is not holding anything In the goal, Object 2 is above object 3. Object 4 is above object Object is Object 1. Object is the topmost object. The robot is not holding anything. Choose sequence of actions to accomplish this task, and retum the action sequence following the example output provided.
LLM; nick(4,) 1, 0), stack(4, 2, 0), p2ck(2, 1, 0), stack(2, 3, 0).
Your plan failed in execution, please generate a different one. This may involve sample new plans or reorder the last plan. Please generate output step- by-step, which includes your reasoning
Prompt:
what the cause of the failure of the last plan? (ii) do you see similar mistakes in other steps in the plan? Here are the failure reasons: Motion planning failed in pick(2, because collision with Object 4.
the failure of the last plan. Asswr the questions:
LLM: Got it! Here my analysis to the planning failures...
Prompt: Now, based on your above failure reasoning for (i) and (ii) generate a new task plan solve the original planning problem. Only return the sequence logical actions following the format of example output.
LLM: pick(2, 1, 0), stack(2, 3, 0), pick(4, 1, 0), stack(4, (4, 2, 0).
26

---

Published as a conference paper at ICLR 2026
B.3.6 RULEASMEM
The overall template of RuleAsMem is very similar to that of LLMTAMP. However, in RuleAsMem, the planning domain is provided and the problem is defined in PDDL syntax.
Part Initialization:
Imagine you are robot arm operator, you need to generate sequence of actions to achieve the given goal. Here is the PDDL planning domain: PDDL planning domain
Part 2. Human demonstrations:
Here are some examples for you to learn:
example of imput and output of the system
Part 3. New planning problem:
Now you are given a new input planning problem as the following: The initial state and the goal of the problem in PDDL syntax. Choose sequence of actions to accomplish this task. Only return the sequence of logical actions following the format of example output.
Example for stacking problem
Imagine you are a robot am operator, you need to generate a sequence of actions to achieve the given goal. Here is the PDDL planning domain:
Prompt:
(define (domain LLM generated ddmaiin (:requärements :strips :equality)
(:predicates
(box ?b1)
(table ?t1)
(above 7b1 2b2)
(holding 2b1 ?r1)
(robot ?r1)
Here are some examples you to learn:
Example input:
Initial state: (top, 2), (box, 2), (on table, 2, 1), (top, 3), (box, 3), (on table, 3, 1), (top,
4), (box, 4), (on table, 4, 1), (table, 1), (not holding, 0), (robot, 0)
Goal state: (top, 2), (box, 2), (above, 2, 3), (box, 3), (above, 3, 4), (box, 4), (on table, 4, 1), (table, 1), (not holding, 0), (robot, 0)
Example Output: pick(3, 1, 0), stack(3, 4, 0), pick(2, 1, 0), stack(2, 3, 0).
Now you are given a new planning problem as the following:
Initial state: (top, 2), (box, 2), (on table, 2, 1), (top, 3), (box, 3), (on table, 1), (top, 4), (box, 4), (on table, 4, 1), (table, 1), (not holding, 0), (robot, 0)
Goal state: (top, 4), (box, 4), (above, 4, 2), (box, 2), (above, 2, 3), (box, 3), (on table, 3, 1), (table, 1), (not holding, 0), (robot, 0)
Choose a sequence of actions to accomplish this task, and return the action sequence following the example output provided.
LLM; pick(2, 1, 0), stack(2, 3, 0), pick(4, 1, 0), stack(4, 2, 0).
27

---

Published as a conference paper at ICLR 2026
B.4
EXPERIMENT TASKS
B.4.1
STACKING
The stacking task involves collecting individual objects and placing them on top of each other to form stable stacks.
B.4.2
UNSTACKING
The unstacking task is the inverse process of stacking, requiring the robot identify, grasp, and remove items from existing stacks without disturbing surrounding structures.
B.4.3
REARRANGEMENT
The rearrangement task demands the robot to relocate objects from an initial configuration into a desired layout.
B.4.4
ALIGNMENT
The alignment task requires the robot to position multiple objects in straight line with consistent spacing and orientation.
B.4.5 COLOR CLASSIFICATION
In the color classification task, the robot must identify the color of each object, group them by color category, and stack or place them in designated areas accordingly.
B.4.6 PARTS ASSEMBLY
The parts assembly task involves recognizing components and sequentially assembling multiple machining parts together.
B.4.7 TOWER OF HANOT
The Tower of Hanoi is puzzle that involves moving stack of disks from one base to another, a time, without ever placing a larger disk on top of a smaller one, using third base as an auxiliary.
B.4.8 BRIDGE BUILDING
In bridge building, the robot required to collect distributed blocks and configure it into a bridge structure.
B.4.9
BURGER COOKING
Lastly, for burger cooking, the robot needs to stack and pack the food ingredients together to make hamburgers.
28

---

Published as a conference paper at ICLR 2026
B.5
GENERALIZATION ACROSS TASK COMPLEXITY
Ours
RuleAsMer
Expert
LLMTAMP
LLMTAMP-FF
LLMTAMP FR
Unstack
Parts Assemblely
Rearrangement
Cooking Burgers
1.00
0.75
0.50
0.25
Success rate
0.00
5
10
15
20
5
10
15
20
5
10
15
20
10
15
Stack
Cube Alignment
Classify Color
Bridge Building
1.00
0.75
0.50
0.25
0.00
5
10
15
5
15
20
5
10
15
20
5
10
Number of objects involved in the tasks
Figure 10: Planning success rate trend across increasing object counts for each task.
29

---

Published as a conference paper at ICLR 2026
B.6 TIME COST OF LLMTAMP REASONING MODEL VARIANTS
As noted in the paper, the reasoning models incur substantial computational overhead when generating task plans. To account for this, extended the time limits for 01-TAMP and R1-TAMP in order to evaluate the contribution of reasoning to planning performance and to enable a fair comparison with our method. This section presents comprehensive comparison of the time costs between the LLMTAMP variants and our approach.
As shown in T our method consistently yields lower average planning times across all tasks compared to the LLMTAMP reasoning model variants. This improvement is primarily attributed PDDLLM's ability structurally summarize the reasoning process into standardized planning domain during a one-time offline inference step. As result, additional reasoning is required at test time. In contrast, LLMTAMP variants conduct reasoning independently for each task instance, leading to significantly higher computational costs. Such overhead makes these models impractical for deployment on physical robots, where real-time planning capabilities are often essential. As shown in Table 2 while o1-TAMP achieves comparable performance in certain tasks, the substantially higher time cost undermines its practical value, particularly in real robotic scenarios.
Table 6: Comparison of time cost between PDDLLM and LLMTAMP reasoning variants
Experiment
Ours
o1-TAMP
o1-TAMP
Average Planning Time Cost (Second)
Stack
5.94
39.22
211.40
Rearrangement
15.74
92.83
337.10
Tower of Hanoi
4.29
167.82
353.88
Bridge Building
6.45
82.47
305.07
30

---

Published as a conference paper at ICLR 2026
B.7 PROMPT VARIATION TEST
In addition to the five main research questions discussed in the paper, we further evaluated the robustness of method under variations in the prompting styles. Four different cases were tested to assess the stability of domain generation: parallel prompting with varying numbers of prompts, altering the prompting sequence of simulation outcomes, and tuning the prompting template.
B.7.1 PARALLEL PROMPTING FOR PDDLLM
We perform parallel prompting of the LLM multiple times to obtain multiple responses simultaneously. These outputs are subsequently analyzed and aggregated to synthesize an optimal solution. The core prompting procedure follows the same structure described Section B.3.1 All the domains failed to execute are removed from the candidate pool. Among those successful planning domain candidates, additional post-processing steps are applied to select, summarize and consolidate the results. For predicate naming, we further prompt the LLM to select the most suitable name from among the parallel outputs. For predicate selection, the prompt template is shown the following:
Here is a list of predicate describing the same object state: predicate list. Please choose the PDDL -==- predicate from the provided ones best describe the scenario. Return the chosen one PDDL syntax.
Similarly, for optimal actions selection:
Here is a list of actions describing the same robot skill: action list. Please choose the PDDL action from the provided ones to best describe the scenario. Return the chosen one in PDDL syntax.
For relevance classification, if the parallel outputs are inconsistent, PDDLLM selects the majority response. In the case of tie, randomly selects one among the tied options.
Example for a choosing predicate from 5 parallel outputs
Prompt: Here is a list predicate describing the same object state: [(above, ?o1, ?o2), (is on, ?o1, ?o2), (aligned vertically, ?o1, ?o2), (on top of, ?o1, ?o2), (above object, ?o1, ?o2) Please choose the PDDL predicate from the provided ones to best describe the scenario. Return the chosen one in PDDL syntax.
LLM: (above, ?o1, ?o2)
Example for choosing predicate from 10 parallel outputs
Prompt: Here is a list of predicate describing the same object state: [(above, ?o1, ?o2), (is on, ?o1, ?o2), (aligned vertically, ?o1, ?o2), (on top of, ?o1, ?o2), (above object, ?ol, ?o2), (above, ?o1, ?o2), (on, ?o1, ?o2), (vertically on, ?o1, ?o2), (on top, ?o1, ?o2), (upper, ?o1, ?o2)]. Please choose the PDDL predicate from the provided ones to best describe the scenario. Return the chosen one in PDDL syntax.
LLM: (on, ?o1, 2o2)
B.7.2 ALTERING THE PROMPTING SEQUENCE OF SIMULATION OUTCOMES
In this prompt variation, we alter the ordering of dimensions presented to the LLM. While the prompt template remains similar to that described in Section B do not adhere to fixed dimension sequence. Instead, we shuffle the order of dimensions within the prompt to evaluate whether this affects the generated output. Some examples are provided here.
31

---

Published as a conference paper at ICLR 2026
Example of prompting object position relation predicate with altered sequence A
Prompt:
There are two objects in the environment, whose positions are (X1,Y1) and (x2,
In the horizontal direction, | x21 s u. In the vertical direction, < Y1 - Y2 S 2u. Please create a predicate in PDDL syntax to describe this relation and classify if it is related to the task of stacking cubes together. Please return the result the following format: predicate, relevance.
LLM: is is_on( , ?022) ), related.
Example of prompting object position relation predicate with altered sequence
There two objects in the environment, whose positions are (x,,y1) and (x2. In the vertical direction, y1 Y2 I 2u. In the horizontal direction, |x, X2 u. Please create a predicate in PDDL syntax to describe this relation and classify if it is related to the task of stacking cubes together. Please return the result in the following format: predicate, relevance.
Prompt:
LLM: is is 0,, ??0z) related.
B.7.3 TEMPLATE TUNING
In this experiment, we aim to evaluate whether slight modifications to the prompt template affect the LLM's ability to generate predicate names and assess their relevance, Here is the fine-tuned template:
There are objects in the environment, whose feature name are feature value and feature value 2. In dimension I, we know feature subspace range in dimension subspace range in dimension 2. Please create a predicate in PDDL syntax to describe this relation. Assign score this predicate indicating its relevance to the task of current task description. The score range is 0 to where 0 indicate irrelevant and indicate very relevant. Please return the result the following format: predicate, score.
dimension 2. we know feature
After collecting the scores, we set threshold to determine which predicates are relevant. In the experiment, the threshold chosen is 0.5.
Example of prompting object position relation predicate with modified template
There are two objects in the environment, whose positions are (x+.y1) and (x2. y2). In the horizontal direction, we know |x, X2l S u. In the vertical direction, we know u < Y1 Y2 S 2u. Please create predicate in PDDL syntax to describe this relation. Assign score to this predicate indicating its relevance to the task of stacking cubes together. The score range is 0 to 1, where indicate irrelevat and indicate very relevant. Please return the result the following format: predicate, score. LLM: above(? o, ? 02 ), 0.9.
Prompt:
The results, presented in Table 7 demonstrate that method remains robust across different prompting styles. Regardless
prompt variation, the generated planning domains consistently solve the test tasks with success rate approaching 100%. Minor fluctuations are attributed to randomness in the planning search process and occasional motion exccution failures.
32

---

Published as a conference paper at ICLR 2026
Table 7: Planning success rate for domains generated using different prompt styles.
Experiment
10-Parallel
5-Parallel
Sequence Altering
Template Tuning
Stack
97.8 97.8%
96.1%
96. 1 1%
95.6%
Unstack
97.8%
100%
98.9%
98.3%
Cube Alignment
100%
100%
100%
100%
B.8 PLANNING TIME LIMIT VARIATION
Table 8: Planning success rate (%) across tasks for methods (Time limit = 25 s).
Method
Expert
LLMTAMP
LLMTAMP-FF
LLMTAMP-FR
RuleAsMem
PDDLLM
Stack
41.5 4.3
56.8 +:
4.8
3.3
97.5
Unstack
99.4
81.2
85.0
79.8
0.
Color Classification
0.1
18.1
24.9
23.1
87.6
9..
Alignment
100.0 +: 0.0
31.6
40.9 2.0
35.3+
96.0 0.8
100.0
Parts Assembly
98.9 0.6 0.6
33.6
46.1
37.3
95.1 15.100.6
100.0 0.0
Rearrange
0.6
3.1
11.7
7.411
1.1
Burger Cooking
100.0::00
27.8
45.1 7.3
1..9
27.8 2.
89.
Bridge Building
100.0
4.3
48.9
4.
2..0
87.2
Tower of Hanoi
83.3 1.3::244 2.4
14.3
14.3 0.0
143+0.0
14.3 1.3+000 0.0
85.7 15.7=000 0.0
Overall
932
3.5
43.2
3.91
0.9
90.5
Table 9: Planning success rate (%) across tasks for all methods (Time limit 100 s).
Method
Expert
LLMTAMP
LLMTAMP-FF
LLMTAMP-FR
RuleAsMem
PDDLLM
Stack
99.5 + 0.5
41.5 4.3
76.7 2.7
71.0
85.5
2.9
97.5 + 1.6
Unstack
96.1 + 0.2
90.3 +
96.9 + 1.2
96.1 1.1
88.4 1.2
97.7 +
Color Classification
100.0 0.0
1.5
42.0 1.9
6.20
88.7 2.3
100.0
Alignment
100.0 0.0
31.6
55.7 3.8
44.3
96.0
100.0
Parts Assembly
98.9 0.6
33.6
57.1 0.8
4..
0.6
100.0
Rearrange
17.4 1.1
1.1
0.5
Burger Cooking
27.8
4.8
51.4+
97.2+
Bridge Building
20.0
87.2
Tower of Hanoi
0.0
0.0
100.0
Overall
95.9 =: 0.1
35.8 0.4
55.6 +: 1.2
54.8
69.9 0.99:000 0.7
94.2 0.5
As outlined in the experimental design section, we set a default planning time limit of 50 seconds reflect the real-time constraints commonly imposed robotic systems. Although prior studies typically allow planning times on the order of minutes (Silver et al. 2021: Khodeir et al. 2023 Huang al. 2025), the exact limits vary considerably. To assess the robustness of our approach under different time allowances, we evaluate performance at time limits of 25, 50, and 100 seconds. The results show that our method consistently outperforms all LLM- LLM-based baselines across all tested time settings and task types. Moreover, the planning domains derived by PDDLLM yield performance comparable to that of expert-designed domains under time settings and across conducted on system with an Intel Core 19-14KKK CPU without GPU
tasks. All simulations acceleration, and all LLM prompting was performed using API services.
33

---

Published as a conference paper at ICLR 2026
B.9 EXAMPLE OF PDDLLM IMAGINED PREDICATES
Table 10: Examples of imagined predicates across multiple categories. Predicate Name
Object Position Predicates
(above 7a 7b1
(forall 7a (above 7a 7b11
(forall (above 3a 2b) is false)
(not (above 2a 26)
(beside 7a 7b!
(sorall za (beside 7a 2b11
(forall ?a. (beside 2a 26) is false)
(act (beside Pa 26))
(txont 7a ib1
(sorall 2a
(forall (front 7a 7b) 18 ralse)
(not (front 7a 26]]
(far-x 2a ?b1
(Forall 2a (far-x 2a 2b11
(torall (tar-x Fa is talss)
(tar-x 7a 76))
(spart-y 2a 2b1
(forall 2a (spart-y 2a 251)
(torall 7a jspart-y 70 76) is ralse)
(not (apart-y za 703)
(distant-x Pa
(fora11 7a
Pa 76))
(forall 2a (distant-x 2a 2b) is fxlsel
(sot (distant-x 2a 2b)
Support Predicates
(on-tablle 2a 21)
[sot fon-Lable 2a (L))
(forall 7a (on-table 2a 2t))
(forall 2a (on-table 2a 25) is false)
(aligned-x 7a
(aligned-x 7t)1
(forall la (aligned-x 7a 2U)
(forall 2a (aligned-x 2a 20) is false)
(aligned-y 70 2t)
[not (aligned-y 7a 7t))
(forall (eligned-y (6)
(forall 2a (aligned-y 2a is Calse) taot (sbove-tab_e 7a st1l
(above-table 2a 2t)
(forall 7a (above-table 7a 2011
(forall 2a (above-table 2a 7t) ia talse]
(cear-x
(not (near-x 21))
(forall 7a (near-x 70 2t))
[forall 7a (near-x 7a 251 is ralae)
(far-x ?a 2t1
(not (far-x Pa 26))
(forall (far-x 2a 26))
(forall 2a (far-x
261 felse)
(far-y 7a it1
hot (far-y 7a 2t11
(forall la (far-y 7a 201)
(forall 78 (far-y 7a 2U1 is falae)
(rear-each Pa ?t)
(not (near-each 2a 7t)1
(forall 7a (neac-each 2a 21)1
(forall 2a (near-each: 2a 21) is false)
Robot Predicates
(tolding 7a 7x)
(not (holding 7a 7+1)
(forall (bolding 22))
(forall 2a (bolding 2x) false)
(grspper-zeax-open 76)
(not (gripger-near-ope
72)1
(fora11 7a igri 7a 79)1
(foral1 7a pper-reerrrrrppeeee Pa 7r) 18 false)
(gripper-Far ?2)
(not (gripper-far 2a ?ri!
(torall (grigper-tar 7a 2E11
(sorall 7a (exipper-tar 72) talse]
(gripper-near 2a 2x)
(act (gripper-neat la 2x1)
(torall (grigger-near 72 2F!)
(torall 7a (gxipper-zear 7x) talse!
Color Predicutes
simi-ar-color 2a fb
(sot sinilac=color 7a 7b1
(forall 7a stmtla=-coler 7a 7b;
(foral1 2a arrcoloo 7a false]
cebbrrate-oolordddffeeeee ie 7b
(not muderate--ulor-da
2a 25)
(forall moderste-colcc-diiieeess distinet-colors
7b)
(forall 2a moderate-color-diieen (not atstinct inct-clloesssse.. 76)
za 2b is false)
(forall la distinct-colors 7a 7b)
(forall 7a inctioccc- 7a. 2b is false)
very-di fera-toorrttttoolllo 7a
vary-dirfaren
7a
(forall Pa fereeet--oooorrr 2a 2b1
(Forall 2a very weeetifeeeetettteeeeee 2a Pb false)
Size Predicates
(ama ?b)
(act (smaller 7b1)
(forall ?s. (smaller 2a 25))
(forall 2a (smailer la 2b) is false)
(larger
(Larger
(fora11 l'argen 7a 76))
(forall 2a (larger 7a 2b1 18 falae)
(longer ?s ?b!
(not (longez 7a 2b))
(torall (Longez 75))
(torall 2a (Longer 7a 7b1 is talse) (not (taller 2a 251)
(taller ?a 2bt
(torall 7a [taller 7a 7b))
(sorall za italler 7a 7b1 is talae)
(wider
(wider Fa 26))
(forall ?a (Midez 26 2b1)
(Forall 2a (wider 2a 2bt is falsel
(tal. 7a 7b)
(aot (tallez-wider 7a 7b1)
(forall (tallez-wider 2e. 2b1) (eider-longer 7a 7b)
(forall 2a (taller-wider
(b) false!
tot (wider-longer 7a 2b1)
(fora11 7a (wider-longer 7a 2b1)
(fora11 2a der--eer 2a 7h) 18 falset
34

---

Published as a conference paper at ICLR 2026
Table 11: Examples of predicate generation across different task and scenes.
Predicates for Weight
Lift a box in warehouse
(light-box ?a) 40 < weight < 70 kg
(heavy-box ?a) 70 < weight < 100 kg
Collect apples of different sizes
(small-apple ?a): 100
166.7 g 233.3 g
(medium-apple ?a) 166.7
(large-apple ?a) 233.3 < < 300 g
Predicates for for Length
Fulfill a 15-cm coffee cup
(needs-refill ?a) 0 level 7.5 cm
(nearly-full ?a) 7.5 level < 11.25 cm
Mcasure high school students' heights
(medium-heighht ?a) 150 < < 160 cm
(average-height ?a) 160 < h < 170
(tall-height, ?a) 170 h 180
(very-tall ?a) 180 h < 190 cm
Predicates for Air Quality
Plan when travel
(suitable-travel 2a): PM2.5 166.7 7
(high-risk ?a) 333.3 PM2.5 500
Predicates for Brightness
Fix broken light office
(dimly-1it ?a): brightness 150 lux
Predicates for Temperature
Heat kitchen stove
(stove-hot ?a) 110 < T < 200 "C
Boil milk
(cold-milk ?a):
10 9g
(warm-milk ?a) < T 90
(boiling-milk ?a): 90 T 100 cC
35

---

Published as a conference paper at ICLR 2026
B.10 TEST PROBLEM SET DESIGN
1.10.1 DIMENSIONS OF DIFFICULTY
Task Diversity: To ensure robustness and broad applicability, sampled over 1,200 planning tasks across nine distinct environments, including stacking, unstacking, rearrangement, alignment, parts assembly, color classification, burger cooking, and bridge building. The details of the tasks provided in Section B.4 Each task category includes tasks of 3 to 20 objects, with 10 distinct tasks sampled for each object count. The resulting task plan lengths ranged from 6 to 510 steps, reflecting a wide spectrum of planning horizons. Our experiments spanned over 150 unique predicates.
Task Complexity: In task design, consider two types of complexity: domain derivation plexity and planning complexity. Domain derivation complexity is determined by the number of predicates imagined and actions invented by PDDLLM; the more predicates and actions, the higher the complexity. Plamning complexity is influenced by both the planning domain and the task. Given objects, task plan of length and actions in the domain, the branching factor at each step is m X n, resulting in approximate complexity of (m x n2). In Section B.10 we layout table showcase the planning complexity (in approximate order of magnitude) of the most difficult problem in the category and the domain derivation complexity. The Tower of Hanoi task exhibits the greatest planning complexity, while bridge building presents the highest domain derivation complexity. In contrast, stack and unstack are simpler in both complexity measures.
Knowledge Transferability: We evaluate the knowledge transferability of PDDLLM by testing its ability generalize from demonstrated tasks to novel ones with overlapping predicates and actions. For most tasks, PDDLLM was given demonstrations of the same task involving fewer (3 to 4) objects. However, for compositional tasks such as rearrangement and bridge building, the model was instead provided demonstrations of simpler subtasks. Specifically, rearrangement used demonstrations from both stacking and unstacking, while bridge building combined demonstrations of stacking and alignment. These setups test whether PDDLLM can compose skills learned from simpler demonstrations solve more complex tasks.
Table 12: Maximum planning complexity and domain derivation complexity of each category.
Task
Stack
Unstack
Color Classify
Alignment
Parts Assembly
Rearrange
Burger Cook
Bridge Build
Tower of Hanoi
Max
Planning
10
10
1071
10
10
10
10
16
10
Complexity
Domain
Derivation
94
114
128
Complexity
1.10.2 DERIVATION OF BOUNDED DOMAIN DERIVATION COMPLEXITY
The predicate imagination complexity measures how many predicates need to be generated. Our method is generalizable to more complex cases for the following reasons:
Complexity calculation formula
The formula
complexity
pp.
nan.i
where i is the number of dimensions included in predicate type i. For example, Adim.color since color is represented by the three RGB channels. Np.i is the number of partitions along each dimension for predicate type i. The term n Win.: gives the total number of predicates generated for type and summing over all predicate types yields the overall complexity of the predicate imagination process for the task.
The Method is Scalable as the Increase in Predicate Types Leads to Linear Growth The number of predicate types grow linearly as the task complexity increases. The only exponential factor
36

---

Published as a conference paper at ICLR 2026
comes from the number of dimensions Vidim per predicate type; however, in practice, this value is typically small (e.g., S 3).
High-Dimensional Features Can Be Decomposed to Reduce Complexity
For higher- nigher-dimeesional
features, as object pose (ar V/ yaw, pitch, roll), decompose them into (ower-dimensional predicate types (e.g.. position and orientation). This reduces exponential complexity to additive linear terms, preserving scalability and enabling rich predicate representation.
Task Planning Does Not Require Many Partitions Dividing features into too many partitions makes predicate implication nearly continuous, which defeats the purpose of symbolic abstraction. Here an experiment:
2 partitions: "cold" (0 < C)")), "hot" (50 < 7' 1000C)
4 partitions: "cool" (0 < < 25*C), "warm" (25 T < 50% "hot" (50 < T < 75,C),
"near-boiling" (75 < < C)
100 partitions "post-boiling" (95 < T < 96 C), "stable-boil" (96 < < 97 C),
For the same task "boil milk", compare the predicate imagination results by forcing the system to partition the feature space into 2, 4, and 100 intervals. It is evident that overly fine partitioning reduces interpretability and semantic efficiency, the number of partitions np per dimension is usually low.
B.11
MISSING AND REDUNDANT ELEMENTS
A redundant predicate action refers to one that, when removed from the planning domain, does not degrade planning performance. Conversely, a missing predicate or action one whose absence significantly reduces the domain's 's planning performance.
The reported percentages are computed by comparing the PDDLLM generated PDDL domains with the expert-designed PDDL domains. The percentage of missing predicates/actions reflects the completeness of the generated domain (i.e., whether all necessary components are present). The percentage of redundant predicates/actionn reflects the optimality of the domain (i.e., whether unnecessary components have been excluded).
B.12 REAL-WORLD DEMONSTRATION COLLECTION
To enable the demonstration collection in real-world, we build up data collection system using Agilex Pika and ArUco markers. We collect both the end-effector trajectories the human demonstrator and the pose of the target objects. These data later mapped symbolic predicates and actions in the PDDL domain, providing bridge between raw demonstration data and high-level planning representations.
End-Effector Trajectory: The movement of the human operator's 's end effector is recorded using the Agilex Pika Data Collection System. The system's 's motion capture capability provides precise position and orientation measurements over time. These trajectories serve as a basis for identifying meaningful segments of motion that can be abstracted into candidate actions for the symbolic domain.
Object Properties and States: Physical characteristics the objects, such as size, are obtained from the available CAD models, ensuring that the symbolic model is grounded in realistic object dynamics. In addition, the poses of the objects during demonstrations are captured using ArUco markers affixed their surfaces. These pose estimates allow us track state changes-such as whether an object has been grasped, moved, or placed-which which are subsequently encoded as predicates in the PDDL formulation.
B. PERCEPTION MODULES AND ABLATION STUDY ON NOISE RESISTANCE
Perception in our real-robot system. For our real-world experiments, we adopt a ArUco markers perception method, which provides reliable object identity and 6D pose estimates. This
37

---

Published as a conference paper at ICLR 2026
setup allows us to evaluate the planning framework without conflating perception errors with the contributions our method.
Compatibility with other perception modules. PDDL task planning is modular and can integrate with other perception systems that provide object state estimation, including learning based (Kase 2020 VLM-based (Liang al.] 2024), standard 6D object-pose estimation methods (Huang et al.
et al.
2025). As our method strietly follows the PDDL pipeline, our approach similarly does not
place restrictive assumptions on how these states are produced, long good state estimation is provided.
Robustness to perception noise. The logical abstraction produced by method is formulated an intersection of intervals, and thus inherently provides tolerance to perception errors: predicates operate on ranges of continuous values rather than exact measurements, which reduces sensitivity to noise. To address your concern, we conduct an additional real world experiment evaluating performance under perturbations of the perceived object state. We randomly place two cm x em x 2 em cubes on a table, use our ArUco marker system to obtain 6D pose estimates, and evaluate each predicate by comparing its predicted truth value against ground-truth spatial relationships inferred from the poses. For each predicate, we construct 50 balanced trials, 25 cases where the predicate should be true and 25 where it should be false. The results are as follows:
Predicates is_on
next_to
Accuracy 94%
96%
In addition, we provide another experiment where we intentionally inject perception noise varying from 5% 30% to imitate perception methods with varied perception accuracy. Each trial is repeated three times, leading to the following results:
Table 13: Accuracy under injected perception noise (percentage noise levels).
Percentage Noise
5%
10%
15%
20 %
25%
30 %
is_on Accuracy
92.7 + 0.9
88.7 + 2.5
84.0 = 3.3
80.7 + 3.4
80.7 + 1.9
78.7 + 0.9
next_to Accuracy
94.7 0.9
84.0 + 1.6
80.0 4.9
76.0 1.00::0 4.3
74.0 + 2.8
69.3 = 1.9
Overall Accuracy
93.7 + 1.4
86.3 + 3.1
82.0 4.6 78.3 + 4.5
77.3 4.1 74.0 + 4.9
The experiment shows that the learned predicates exhibit strong tolerance to perception noise, with significant degradation occurring only when injected noise exceeds 20%. This demonstrates the feasibility of integrating our system with current perception technologies.
B. APPLICABLE SCENARIOS ANALYSIS
Suitable Domains The proposed system is naturally suited to domains that align with the classical task and motion planning (TAMP) setting (Garrett al. 2021: Kaelbling & Lozano-Péren 201 1),
namely those with: (1) consistent object physical attributes, (2) scene geometry can be represented with structured models such as URDF/CAD, so that motion- paanninn constraints can be grounded reliably. Such tasks have already included a wide range of regular robotic tasks, suas table tidying, object sorting, cabinet and drawer organization, simple assembly, etc.(Garrett et al. 2021 Silver et al. 2021 Huang et al., 2025; Silver et al., 2024) These prior studies have largely verified the task and motion planning framework in those domains.
While modern simulators are powerful, we recognize that some domains remain difficult to model reliably, which remains challenge shared across the robotic planning community. Here discuss those domains that are specifically challenging Deformable, fluid, or highly non-rigid materials (c.g., cloth, liquids), where feature definition is under studied and reliable physics simulation is still limited. (2) Tasks requiring fine-grainee feature modeling, such as tight-tolerane simulation yield large discrepancies in behavior. (3) Unstructured or rapidly changing environments, where object properties or contacts vary unpredictably and cannot be captured with static models.
Challenging Domains
approach. (1)
insertion, dexterous geometry manipulation, where small errors in
How our method remain helpful in challenging situations with complex dynamics?
38

---

Published as a conference paper at ICLR 2026
There two main aspects:
Easing human workload by automating common-dynamies predicate generation. In challenging domains, the planning domain produced by our approach still provides a strong starting point. Although it may not fully capture the most complex dynamics. reliably constructs predicates that describe common and regularly occurring dynamics. This leaves only a small number of highly complex predicates for engineers to refine, avoiding the need to rebuild the entire domain from scratch and substantially reducing manual effort.
Empirical compatibility with manipulation techniques designed for complex dynamics. Our method can be integrated with stronger low-level manipulation modules such as VLA, which are specifically engineered to handle complex dynamics. We also include table- setting experiment where our framework combined with a finetuned version of PiO as the low-level skill controller, achieving a 7/10 success rate in real-robot trials.
B.15 ABLATION STUDY: HYPERPARAMETER
For subspace granularity hyperparameter we perform an ablation study on the selection of Specifically for selection, for each continuous feature S. uy has to smaller than the smallest non-zero observed difference dyai of that feature among all relevant objects. This provides conservative upper bound of y otherwise the system cannot capture distinctions of all objects. Thus, ablates the selection of from diii to 0.25dmmn-- We fix Reprompt 10 for all experiments. Three runs were performed for per y per task, and the average missing/redundant percentage compared to human design is reported.
Table 14: Effect of the threshold redundant and missing predicates across tasks.
Tasks
Error Type
dmin
Ur 0.75dmin
0.5dmin
Ur 0.25dmmin
Stacking
Redundant 8.3%
12.5%
16.7%
12.5%
Stacking
Missing
4.2%
0.0%
0.0%
4.2%
Tower of Hanoi
Redundant
14.3%
14.3%
9.5%
14.3%
Tower of Hanoi
Missing
0.0%
0.0%
0.0%
4.2%
Bridge Building
Redundant
3.7%
11.1%
14.8%
22.2%
Bridge Building
Missing
22.2%
22.2%
22.2%
22.2%
Burger Cooking
Redundant
3.7%
7.4%
18.5%
22.2%
Burger Cooking
Missing
22.2%
22.2%
25.9%
22.2%
Overall
Redundant
7.5%
11.3%
14.9%
17.8%
Overall
Missing 12.1%
11.1%
12.0%
13.2%
To conclude, reducing overall would increase the risk of redundant predicates, but the negative effect on missing predicate less apparent. Overall, the predicate generation not very sensitive to variation of u. Usually it is also not necessary to set extremely small u. In our implementation, we allow LLM to adjust u. Specifically, the LLM can merge intervals that are semantically uninformative for the task into single broader region, and subdivide intervals in feature regions where finer distinctions are necessary.
16 ABLATION STUDY: PARALLEL PROMPT
This Section include ablation study number of parallel prompt Rprrmpt with respect to (1) the domain generation success rate. (2) domain quality with respect to human design.
1.16.1 INFLUENCE ON DOMAIN GENERATION SUCCESS RATE
Empirically, the system consistently produces executable planning domain when using five or more parallel prompts. We evaluate four domains, Stacking, Tower Hanoi, Bridge Building. and Burger Cooking, which span wide range of domain-generation complexities. For each value of
39

---

Published as a conference paper at ICLR 2026
proomp: every task is tested with three independent parallel runs. The overall failure rate of producing an executable planning domain as function of the number of parallel prompts is reported below.
Table 15: Rate of failure to generate executable domain with varying number of parallel prompt
Tasks
procmp
Perumpt
5
prompp
10
Pprompx
15
7promp: 20
Overall Failure Rate(%)
41.7
8.3
8.3
B.16.2 INFLUENCE ON DOMAIN QUALITY COMPARED TO HUMAN DESIGN
The result of varying Aprompt is shown in the table below. We the selection of uy dman for all experiments. Three runs were performed for per Nyrompt per task, and the average missing/redundant percentage compared to human design is reported.
Table 16: Redundant and missing predicate rates across tasks as the number of parallel prompts changes.
Tasks
Error Type
Tppromp
Apeumpp
5
Aprompi
10
Tirrompt
15
Appcmpp
20
Stacking Stacking
Redundant Missing
25.0% 4.2%
12.5%
8.3%
4.2%
4.2%
0.0%
4.2%
0.0%
0.0%
Tower Hanoi
Redundant Missing
38.1%
9.5%
14.3%
14.3%
9.5%
Tower of Hanoi
0.0%
0.0%
0.0%
0.0%
0.0%
Bridge Building
Redundant Missing
33.3%
11.1%
3.7%
3.7%
0.0%
Bridge Building
29.6%
25.9%
22.2%
22.2%
22.2%
Burger Cooking
Redundant Missing
29.6%
11.1%
3.7%
11.1%
0.0%
Burger Cooking
29.6%
22.2%
22.2%
22.2%
22.2%
Overall Overall
Redundant Missing
31.5%
11.1%
7.5%
8.3%
3.4%
15.8%
12.0%
12.1%
11.1%
11.1%
B.17 EFFECT OF MISSING COMPLEX PREDICATES
The complex predicates are missed more frequently when they require deep or repeated operator com- positions (e-g..
bases_ _bases_finneeee w.fffishedi which involves multiple nested forall quantifiers and conjunctions). Such structures expand the candidate space combinatorial, making them harder the LLM to reason nested logic and identify consistently. In contrast, simpler higher-order predicates, such as on_top, which require only shallow or singular compositions, are generated reliably with almost no missing observed. In practice, missing highly composite predicates rarely leads to direct planning failure. The essential geometric and relational structure is already captured by first-order predicates; the more complex, higher-order predicates primarily serve to accelerate plan- ning by enforeing appropriate action ordering. For example, omitting mall__aaee____ fini shd in the bridge-building task causes the planner to initiate surface assembly prematurely, encounter motion- poaaning failure, and then backtrack assemble the remaining bases. Our experiments still achieve over 85% success even without such predicates-thus, the increased planning time does not cause immediate failure typical settings. However, this becomes more problematic for time-sensitive tasks. In scenarios with strict latency requirements or limited search budgets, missing these complex predicates may cause the planner exceed the allotted time, effectively resulting in task failure even though valid plan is reachable.
B.18 REFINING PREDICATE PRECISION WITH IMPROVED LANGUAGE GUIDANCE
Here provide additional experiment that illustrates how refined language guidance can improve the predicate precision. The only change we made in the following experiment is the task description. All other settings consistent with the experiments in the main paper.
40

---

Published as a conference paper at ICLR 2026
Table 17: Examples of predicate generation across different task and scenes.
Predicate Name
Heat Milk
(hot-milk Pal: 40 T < 60 "C
(werm-mi 1k ?a): 20 < 2 40 "C
Boil milk
(cold-milk :a): 0
10 "
(warm-milk Pa) 20 < 40
90
(boiling-milk ?a): 90 < T 100 "C
cold milk from fridge until it comes to boil.
(cold-milk 2a):
< 10 90
(near-boil-mill) 2a) 80
90
(boiling-milk Pal: 90 T 100 90
As shown in the results, vague language prompts lead vague predicates and loose predicate constraints. When the instruction becomes more specific, the generated predicates also become more precise, with correspondingly sharper constraints.
B.19 FEEDBACK LOOP FOR LOW-LEVEL MOTION FAILURE
We recognize that low-level execution inaccuracies are indeed common challenge in task and motion planning methods (Kaclbling Lozano- Lozano-Pérez: 2001 Garrett 2018 Silver et al. 2023). In framework, follow the standard task and motion planning paradigm to handle such failures. When a low-level failure occurs (e.g.. the third block falls because the second block was not perfectly centered), it result in logical state change. The PDDL planner then re-in re-invokes symbolic planner to generate a new sequence of actions that recovers from the failure by re-stacking the misplaced block. This replanning-execution loop is repeated until either the goal is achieved the time limit is reached. This mechanism ensures that occasional geometric inaccuracies do not terminate the task prematurely.
B.20 TOKEN COST DETAILS
The following table shows the token cost observed in each of trials for three tasks. The average value is reported in the main paper Table 2. Each trail we adopt u = dmiu and Mprompt 10.
Table 18: Token cost (k) across 5 trials for each task in domain derivation.
Task
Trial
Trial
Trial
Trial
Trial
Avg
Rearrangement
306.4
292.9
322.5
465.1
285.2
334.4
Tower of Hannoi
478.6
526.6
558.6
547.2
564.1
535.1
Bridge Building
293.0
478.2
336.5
471.0
298.0
375.3
41

---

Published as a conference paper at ICLR 2026
B.21 ABLATION STUDY: LLM BACKBONES
To assess whether PDDLLM depends on GPT-4o, we repeated all experiments using Qwen3-4B and Qwen3-8B as backbones. As shown in Table 8, both models achieve performance comparable GPT-4o across all tasks. The maximum discrepancy across the nine tasks is small (within 2-3% for most tasks), and the average deviation from the GPT-4o results under 1%. The results are expected. as once planning domain is derived, the downstream success rate primarily depends on the PDDL solver rather than the choice of LLM backbone.
Table 19: Performance (%) of PDDLLM with different LLM backbones.
Align
Burger
Bridge
GPT-4o
97.5 1.6
97.7
100 2: 0.0
100 à: 0.0
100 a: 0.0
64.3 0.7
91.7 à: 4.8
87.2 à: 4.3
100 2:00:00.
9 100
Qwen3-IB
97.51.8
Qwen3-SB
97.8
=00
100 0.0
100 4 0.0
98.1 =
66.1 2/2
96.1 2.5
85.0 a 5.0
9006 0.5
42


Reviews:
[{"review_id": "OybKzWxBjz", "reviewer": "Reviewer_MY9K", "summary": "This paper presents a new method that is capable to generate a complete planning domain from scratch, without relying on any predefined predicates or actions. The method employs the reasoning ability of LLMs to do generation based on demonstration.", "questions": "Please see the weaknesses part.", "limitations": "", "rating": 4, "confidence": 3, "soundness": 3, "presentation": 2, "contribution": 2, "strengths": "This work targets an interesting and meaningful problem in planning.\n\nThe proposed methodology does not rely on pre-defined predicate space and action model, which reduce the effort of human annotation.\n\nExperimental in real robot environments demonstrates the effectiveness of the proposed method.", "weaknesses": "**Major**\n\nSuccessful deployment of the proposed method requires a perception function that can accurately extract the continuous states from objects. It is unclear what types of the perception function the proposed method can work along well.\n\nIt was not extensively discussed in the paper how robust the proposed method is with respect to any noises in the perception process.\n\nIt seems that applying the proposed method in real applications requires setting up a same digital copy in a simulation. This limits the potential applicable areas as setting up simulation in some domains requires laborious manual modelling even for feature parameters. It would be better to discuss what kind of domain the proposed method can easily handle, and what domains the proposed method may encounter big challenges.\n\n**Minor**\n\nSome paragraph is not written with clear motivations, which makes the reading not easy to follow. For example, L180-L196, it is unclear why the method is dividing the feature space. It would be better to clearly explain the target problem at the moment, e.g., use parallel simulations to imagine predicates by summarizing the simulation roll-outs with LLMs, and explain what the challenges are.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "EeOGHeCdI0", "reviewer": "Reviewer_h5Ug", "summary": "This paper proposes PDDLLM, a framework that automatically generates the PDDL planning domain from one demonstration by combining LLMs with physical simulation. It introduces a Logical Constraint Adapter (LoCA) to automatically ground the generated symbolic actions into motion constraints, enabling seamless integration with motion planners and real-robot execution. Experiments on 9 tasks show that PDDLLM outperforms baselines and achieves performance comparable to expert-designed domains.", "questions": "The paper claims that the framework can integrate knowledge across demonstrations. In this context, during the evaluation, were demonstrations from other tasks used to assist the construction of the domain model for the current task?", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. This paper aims to automatically generate planning domains from one demonstration to reduce manual engineering efforts, which is a valuable goal for the field. \n2. Experiments on 9 tasks show that the proposed method achieves a high success rate, outperforming other baselines.", "weaknesses": "1. The paper relies on a physics simulator to evaluate the physical feasibility of predicates. However, such simulation-based evaluation may fail to capture complex dynamics, limiting the method’s generalization to real-world settings. The current experiments only involve simple rigid-body interactions, so it remains unclear how the proposed approach would perform with more complex objects such as deformable materials or fluids.\n2. There are several unclear aspects in the paper:\n(1) It is not clearly stated whether the predicates must be predefined or can be freely generated by the LLM based on the task and scene. If predicates are required in advance, this could constrain the generality of the proposed framework.\n(2) The paper mentions that “the range of each feature is divided into intervals, with the length of each interval being a hyperparameter,” but does not specify how this hyperparameter is determined. Is it fixed manually or generated adaptively by the LLM?", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "Xx2oIl7jw7", "reviewer": "Reviewer_3sZG", "summary": "The submission proposes a framework to derive a symbolic planning domain from a single demonstration. It achieves this through predicate “imagination” from simulator roll-outs summarized by an LLM and action “invention” from logical state transitions. Then the produced domain can be used with a PDDL motion planner. The authors evaluate across  several tasks and environments and report large gains over LLM-enabled planners (with a fixed planning budget), includingl real-robot executions on three platforms.", "questions": "Can you add an ablation for u and for the number of parallel prompts? Including domain quality metrics (missing/redundant predicates) \n\nCan you include more quantitative per platform metrics for real robot experiments?\n\nCan you disambiguate token costs across domain derivation and per-task planning?", "limitations": "", "rating": 6, "confidence": 2, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "The submission tackles the costly manual domain-spec bottleneck in TAMP and positions the work among LLM planners and domain-inference lines of work. The end-to-end automation pipeline (predicate imagination, action invention  and LoCA) is, in my understanding, the main contribution/novelty. The tasks are varied in difficulty and nature (Tower of Hanoi, bridge building, burger cooking), and multiple SOTA baselines are included (LLMTAMP, LLMTAMP-FF/FR, o1-TAMP, R1-TAMP, RuleAsMem). Analysis of time-limit is provided, which can be relevant when planning under a fixed time budget in real applications. Real robot demonstrations strengthen the empirical support of the frameworks effectiveness.", "weaknesses": "Since the pipeline still relies on some hand-chosen design choices (e.g. $u$ for subspace granularity), statements about constructing domains \"without manual predesign\" might be exaggerated.\n\nHow often does the limited operator set miss required invariants? First-order predicates come from discretized subspaces while higher-order ones use a limited set of logical operators/quantifiers. The limitations section admits missing complex predicates (e.g., ordering constraints), which can materially affect plans in more challenging domains.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "tepeKU3BUz", "reviewer": "Reviewer_ZvYq", "summary": "The paper introduces PDDLLM, a novel framework that enables LLMs to autonomously generate symbolic planning domains from a single human demonstration. PDDLLM derives both automatically by integrating LLM reasoning with physical simulation. Its Logical Constraint Adapter further connects high-level symbolic plans with low-level motion planning, allowing end-to-end execution. Evaluations across over  nine environments demonstrate that PDDLLM outperforms LLM-based baselines in success rate, planning efficiency, and token cost.", "questions": "Questions:\n- Once a predicate is proposed with constraints, it appears that it is never updated. What happens if the constraints are incorrect? How do you ensure that the hyperparameters within these constraints are generalizable?\n- In Figure 2’s illustration, the x, y, and z axes all share the same hyperparameter u. Why is this the case, and how was u selected?\n- How do you handle low-level failures? Although the motion planning is formulated as a constrained optimization problem, the inequality constraints can accumulate errors. For example, in the stacking task, the third block may fall if the second block is not perfectly centered on the first one.\n\nComments: \n- L201-203, PDDL clauses have no comma in it\n\nMissing literature: \n\nZhu et al., PSALM-V: Automating Symbolic Planning in Interactive Visual Environments with Large Language Models. 2025", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- PDDLLM automatically derives predicates and actions from a single demonstration without manual engineering or predefined templates.\n- Strong empirical results, outperforms six LLM-based baselines across 1,200 tasks.\n- Demonstrates effective transfer of learned domains and actions to new, unseen tasks and environments, on multiple robot platforms.", "weaknesses": "- The difference from InterPreT is unclear. It seems PDDLLM replaces human-crafted planning examples with a single demonstration and a predefined constraint pool for predicate generation. More clarification on how this differs conceptually or technically would strengthen the paper.\n- Is GPT-4o necessary to achieve the reported performance? Have the authors tested other LLMs?\n- Since the method lacks a feedback loop, it seems to require perfect constraint design, perfect predicate specification, and perfect action proposals. A single failure at any step could lead to a catastrophic outcome. It is unclear why the method is described as robust and generalizable, could the authors provide examples demonstrating successful performance with imperfect intermediate steps?", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)