Literature
Display
← All papers

Learning Adaptive Planning Representations with Natural Language Guidance

Lionel Wong · Jiayuan Mao · Pratyusha Sharma · Zachary S. Siegel · Jiahai Feng · Noa Korneev · Joshua B. Tenenbaum · Jacob Andreas

· ICLR 2024 ↗

Robotics7 min text · CondensedOriginal paper ↗
Contents

Overview

Ada uses language-model proposals to build planner-compatible action libraries and grounds those actions through environment interaction.

At a glance

Action Domain Acquisition learns high-level symbolic operators and reusable low-level control routines for a collection of language-described tasks. A language model proposes goals and operators; a hierarchical planner and execution feedback test their usefulness. The reported experiments solve all tested Mini Minecraft tasks and 79% of selected ALFRED tasks under a best-of-proposals protocol. These results assume predefined predicates, state abstractions, goal checking, and simplified navigation, rather than learning planning directly from raw visual observations.

1 Introduction

Long tasks become easier when useful subgoals and reusable actions are available, but those abstractions are often hand-designed. Ada uses linguistic background knowledge as a proposal source and environment interaction to filter it. The intended library must support symbolic composition and realizable local control. Language-model output alone is not treated as an executable or universally correct world model.

Refer to caption
Figure 1: Our approach solves complex planning tasks specified in language and grounded in interactive environments by jointly learning a library of symbolic high-level action abstractions and modular low-level controllers associated with each abstraction. Our system leverages background information in language as a prior to propose useful action abstractions, then uses a hierarchical planning framework to verify and ground them.

2 Problem Formulation

The formulation assumes deterministic low-level transitions, a fixed known mapping from raw states to symbolic predicates, and language-described goals whose success can be queried. Each high-level operator contains a name, typed arguments, preconditions, effects, and an associated controller. A symbolic plan sequences operators; low-level procedures attempt to achieve their effects.

Operator semantics ideally promise successful effects whenever preconditions hold, but the learned library is validated by finite executions and thresholds. Empirical acceptance does not prove that promise over every possible state. The given predicates, abstraction map, and success signal are substantial prior structure.

Refer to caption
Figure 2: Representation for our (a) task input, (b) the bi-level planning and execution pipeline for inference time, and (c) the abstract state and action representation.
Refer to caption
Figure 3: The overall framework. Given task environment states and descriptions, at each iteration, we first propose candidate abstract actions (operators) 𝒜i′{\mathcal{A}}_{i}^{\prime}, then uses bi-level planning and execution to solve tasks. We add operators to the operator library based on the execution result.

3 Action Abstractions from Language

Each iteration proposes candidate operators, translates task goals, attempts hierarchical plans, learns local control routines, and retains operators with enough successful executions. The process aims to adapt both abstraction granularity and control to the domain, rather than simply accumulate every plausible language-generated skill.

Algorithm 1 Action Abstraction Learning from Language
1: Dataset of tasks and their language descriptions {ℓt}\{\ell_{t}\}
2: Predicate set 𝒫{\mathcal{P}}
3: Optionally, an initial set of abstract operators 𝒜0{\mathcal{A}}_{0}, or 𝒜0=∅{\mathcal{A}}_{0}=\emptyset
4: Initialize subgoal-conditioned policy πθ\pi_{\theta}.
5: for i=1,2,⋯,Mi=1,2,\cdots,M do
6:   𝒜i←𝒜i−1∪ProposeOperatorDefinitions​(𝒫,{ℓt}){\mathcal{A}}_{i}\leftarrow{\mathcal{A}}_{i-1}\cup\text{ProposeOperatorDefinitions}({\mathcal{P}},\{\ell_{t}\}) ⊳\triangleright Section 3.1
7:   for each unsolved task jj: (x0(j),ℓt(j))(x^{(j)}_{0},\ell^{(j)}_{t}) do
8:    u¯←BiLevelPlan​(𝒜i,ℓt(j),π)\bar{u}\leftarrow\text{BiLevelPlan}({\mathcal{A}}_{i},\ell^{(j)}_{t},\pi) ⊳\triangleright Section 3.2
9:    result(j)←Execute​(x0(j),u¯)\textit{result}^{(j)}\leftarrow\text{Execute}(x^{(j)}_{0},\bar{u}) ⊳\triangleright Execute the plan   
10:   θ←UpdateSubgoalPolicy​(θ,result)\theta\leftarrow\text{UpdateSubgoalPolicy}(\theta,\textit{result}) ⊳\triangleright Section 3.3
11:   𝒜i←ScoreAndFilter​(𝒜i,result){\mathcal{A}}_{i}\leftarrow\text{ScoreAndFilter}({\mathcal{A}}_{i},\textit{result}) ⊳\triangleright Section 3.4 return 𝒜M{\mathcal{A}}_{M}
Refer to caption
Figure 4: Our two-stage prompting method for generating candidate operator definitions. (a) Given a task instruction, we first prompt an LLM to generate a candidate symbolic task decomposition. (b) We then extract undefined operator names that appear in these action sequences and prompt an LLM to generate symbolic definitions.

3.1 Operator Proposal

A first prompt decomposes tasks into named actions using language goals and a shortened symbolic state containing unary features. Undefined action names then seed a second prompt that generates typed PDDL preconditions and effects. Syntax repair removes invalid predicates or types and can leave an operator underspecified; execution-based filtering must handle those remaining errors. The proposed action sequence is used to discover vocabulary, while a formal planner builds the eventual plan.

Equation
𝒜i←𝒜i−1∪ProposeOperatorDefinitions​(𝒫,{ℓt}){\mathcal{A}}_{i}\leftarrow{\mathcal{A}}_{i-1}\cup\text{ProposeOperatorDefinitions}({\mathcal{P}},\{\ell_{t}\})

3.2 Goal Proposal and Bi-Level Planning

The model proposes several first-order goal formulas because natural-language descriptions can be ambiguous. Fast Downward searches for a symbolic plan under the candidate operators. Each operator’s instantiated effects become a local subgoal, which receives a bounded low-level search budget. A complete low-level sequence is finally checked against the environment’s hidden true goal.

Successful local effects and correct interpretation of the final task are distinct: a physically feasible sequence can still solve the wrong proposed goal. Multiple proposals and an external task-success checker are part of the reported performance.

Equation
for each unsolved task (x0(j),ℓt(j))(x^{(j)}_{0},\ell^{(j)}_{t}):
u¯←BiLevelPlan​(𝒜i,ℓt(j),π)\displaystyle\qquad\bar{u}\leftarrow\text{BiLevelPlan}({\mathcal{A}}_{i},\ell^{(j)}_{t},\pi)
result(j)←Execute​(x0(j),u¯)\displaystyle\qquad\textit{result}^{(j)}\leftarrow\text{Execute}(x^{(j)}_{0},\bar{u})

3.3 Policy Learning and Guided Low-Level Search

Local search experience is reused through a shared subgoal-conditioned controller. The implemented controller is a dictionary of lifted action sequences, rather than the neural policy suggested as an option in the general framework. Hindsight relabeling turns encountered state changes into additional achieved subgoals, even when a search fails its original objective.

Equation
θ←UpdateSubgoalPolicy​(θ,result)\theta\leftarrow\text{UpdateSubgoalPolicy}(\theta,\textit{result})

3.4 Scoring LLM Operator Proposals

An operator is retained only after enough attempted uses and a sufficiently high ratio of successful local-subgoal executions. This tests practical compatibility with the controller and environment. Its score does not depend on whether the language model’s final-goal interpretation matches the true task, and a high empirical ratio is not a formal soundness certificate.

Equation
𝒜i←ScoreAndFilter​(𝒜i,result){\mathcal{A}}_{i}\leftarrow\text{ScoreAndFilter}({\mathcal{A}}_{i},\textit{result})

4 Experiments

Mini Minecraft tests mining, crafting, and their composition, with over two thousand possible grounded actions and up to twenty-six steps excluding path planning. ALFRED uses household tasks in simulation, with predefined object/state predicates and goal descriptions. Both environments provide a direct move-to primitive, removing ordinary navigation planning from the evaluation.

Except for the stated compositional-transfer settings, systems make two learning passes over the same randomly ordered tasks whose final accuracy is reported. Four goal proposals, four task decompositions, and three operator-definition proposals are sampled; a task counts as solved if at least one proposed-goal attempt passes verification. Thus the headline scores are best-of attempts after interactive task exposure, not single-shot held-out success.

Low-level search budgets are at most one thousand nodes per Minecraft subgoal and fifty per ALFRED subgoal. The ALFRED subset contains 223 tasks after manually removing 27 of an initial 250 whose language goals were judged completely misspecified. Baselines adapt goal-only planning, language-predicted subgoals, and a Voyager-like Python skill library. They are reimplementations within this setup, not a direct comparison to the original systems’ full benchmark results.

Refer to caption
Figure 5: Top: (a) Visualization of the Mini Minecraft environment, showing an intermediate step towards crafting a bed. (b) Operator proposed by an LLM and verified by our algorithm through planning and execution. (c) Visualization of the low-level crafting tools involved in crafting the bed. Bottom: (a) Visualization of the ALFRED household environment. (b) Example operators proposed by LLM and verified by our algorithm, which are composed to solve the cold potato slice task.

4.1 Results

With GPT-3.5 and three replications, Ada reports 100% on mining, crafting, and compositional Minecraft tasks. Skills for the compositional Minecraft test come from simpler mining/crafting training. On the selected ALFRED set, Ada reaches 79% versus 21% for low-level planning only and 2% each for the subgoal and code-policy baselines. The original table pairs 100% means with nonzero standard deviations of 7.5% and 4.1% in two Minecraft columns; this inconsistency is preserved and not reconciled into invented corrected values.

The learned household libraries recover the needed operator structure, with slicing sometimes split into knife-specific operators or restricted to one knife type. Remaining failures include incorrect goal interpretation, limited low-level geometric control, and overrestrictive operators. The true goal appears among the top four proposals about 92% of the time, which measures proposal coverage rather than successful execution.

The code-library baseline must also rely on a language model to sequence Python skills and grows a much larger library. The results therefore compare complete representation/planning designs, not just programming-language syntax. The appendix’s GPT-4 comparison again favors Ada: 100% across Minecraft and 70% on ALFRED versus 12/37/11% and 11% for the code baseline. GPT-4 does not improve Ada’s reported ALFRED score over the GPT-3.5 setting.

Mini Minecraft (n=3) LLM Predicts? Library? Mining Crafting Compositional
Low-level Planning Only Goal ✗ 31% (σ\sigma=0.0%) 9% (σ\sigma=0.0%) 9% (σ\sigma=0.0%)
Subgoal Prediction Sub-goals ✗ 33% (σ\sigma=1.6%) 36% (σ\sigma=5.6%) 6% (σ\sigma=1.7%)
Code Policy Prediction Sub-policies ✓ 15% (σ\sigma=1.2%) 39% (σ\sigma=3.2%) 10% (σ\sigma=1.7%)
Ada (Ours) Goal+Operators ✓ 100% (σ\sigma=0.0%) 100% (σ\sigma=7.5%) 100% (σ\sigma=4.1%)
ALFRED (n=3 replications) LLM Predicts? Library? Original (Simple + Compositional Tasks)
Low-level Planning Only Goal ✗ 21% (σ\sigma=1.0%)
Subgoal Prediction Sub-goal ✗ 2% (σ\sigma=0.4%)
Code Policy Prediction Sub-policies ✓ 2% (σ\sigma=0.9%)
Ada (Ours) Goal+Operators ✓ 79% (σ\sigma=0.9%)
Table 1: (Top) Results on Mini Minecraft. Our algorithm successfully recovers all intermediate operators for mining and crafting, which enable generalization to more compositional tasks (which use up to 26 operators) without any additional learning. (Bottom) Results on ALFRED. Our algorithm recovers all required household operators, which generalize to more complex compositional tasks. All results report mean performance and STD from n=3 random replications for all models.

5 Related Work

Prior work uses language models to predict plans, formal goals, executable code, or learned abstractions. Ada’s distinguishing choice is to learn reusable symbolic operators that can be searched by an established planner and connected to local control. It draws on hierarchical planning and program-library learning, while relying on a supplied symbolic state vocabulary and interaction-based validation.

6 Discussion and Future Work

The framework does not learn its initial predicates from perception or tackle detailed geometric motor planning. It also relies on a general-purpose language model and externally checkable goals. Proposed extensions include perceptual predicate acquisition and transferring the learned planning structure into faster models. The current evidence supports structured domain acquisition in the two simplified simulation settings, not autonomous robot deployment from raw inputs.

Appendix A Appendix

The appendix specifies prompting, syntax repair, local search, a GPT-4 comparison, and the complete example planning domains. The original source libraries omitted from the HTML are restored below.

A.1 Additional Methods Implementation Details

Implementation details explain the supplied examples, sampling choices, and memory of successful local trajectories that affect reproducibility.

A.1.1 LLM Prompting

Experiments use gpt-3.5-turbo-16k with temperature one. Decomposition and operator prompts include constructed examples that avoid the target learned skills, then add successful examples from later iterations. Goal prompting separately uses ground-truth goal definitions from a randomly chosen 10% of the training distribution as initial supervision; the approach is therefore not free of labeled goal examples.

To obtain diverse alternatives, prompts ask for several distinct definitions directly rather than relying only on repeated token sampling. Invalid predicates and arguments are removed or repaired using known domain typing, and empty effects/goals are rejected. Such repairs can erase necessary conditions, which is why subsequent environment validation remains essential. The exact goal- and operator-proposal budgets are those described in the main setup.

Mini Minecraft LLM Predicts? Library? Mining Crafting Compositional
Code Policy Prediction Sub-policies ✓ 12% 37% 11%
Ours Goal+Operators ✓ 100% 100% 100%
ALFRED (n=3 replications) LLM Predicts? Library? Original (Simple + Compositional Tasks)
Code Policy Prediction Sub-policies ✓ 11%
Ours Goal+Operators ✓ 70%
Table 2: Results with GPT-4 as the LLM backbone: On both Mini Minecraft (Top) and ALFRED (Bottom), our algorithm recovers all required operators, which generalize to more complex compositional tasks. Switching to GPT-4 does not impact performance trends observed across the Code as Policies (Voyager) baseline and our method.

A.1.2 Policy Learning and Guided Low-level Search

A dictionary maps lifted subgoal descriptions to candidate action trajectories. Object names are replaced with variables so successful routines can transfer across instances. Matching stored trajectories are tried first and ranked by observed success counts; otherwise the method falls back to breadth-first search. Every explored trajectory can contribute a hindsight-labeled state-change example, even when it fails the current target.

A.2 Experiments

The complete original Mini Minecraft and ALFRED domain files are retained verbatim from the paper’s arXiv source archive. They include the supplied types, constants, predicates, and initial actions as well as the example learned operators. These are libraries from a sampled run, not a compact list containing only newly acquired skills.

The Minecraft file exposes inventory and hypothetical-object bookkeeping for mining and crafting, while the household file includes pickup/placement, rinsing, toggling, cooling, knife-specific slicing, and heating. Original names, duplicate variants, indentation, and syntax are preserved for inspection; restoration does not silently repair or revalidate the planners’ domains.

Original Mini Minecraft PDDL library
(define (domain crafting-world-v20230404-teleport)
(:requirements :strips)
(:types
   tile
   object
   inventory
   object-type
)
(:constants
  Key - object-type
  WorkStation - object-type
  Pickaxe - object-type
  IronOreVein - object-type
  IronOre - object-type
  IronIngot - object-type
  CoalOreVein - object-type
  Coal - object-type
  GoldOreVein - object-type
  GoldOre - object-type
  GoldIngot - object-type
  CobblestoneStash - object-type
  Cobblestone - object-type
  Axe - object-type
  Tree - object-type
  Wood - object-type
  WoodPlank - object-type
  Stick - object-type
  Sword - object-type
  Chicken - object-type
  Feather - object-type
  Arrow - object-type
  Shears - object-type
  Sheep - object-type
  Wool - object-type
  Bed - object-type
  Boat - object-type
  SugarCanePlant - object-type
  SugarCane - object-type
  Paper - object-type
  Bowl - object-type
  PotatoPlant - object-type
  Potato - object-type
  CookedPotato - object-type
  BeetrootCrop - object-type
  Beetroot - object-type
  BeetrootSoup - object-type

  Hypothetical - object-type
  Trash - object-type
)
(:predicates
   (tile-up ?t1 - tile ?t2 - tile)     
   (tile-down ?t1 - tile ?t2 - tile)   
   (tile-left ?t1 - tile ?t2 - tile)   
   (tile-right ?t1 - tile ?t2 - tile)  

   (agent-at ?t - tile)
   (object-at ?x - object ?t - tile)
   (inventory-holding ?i - inventory ?x - object)
   (inventory-empty ?i - inventory)

   (object-of-type ?x - object ?ot - object-type)
)

(:action move-to
  :parameters (?t1 - tile ?t2 - tile)
  :precondition (and (agent-at ?t1))
  :effect (and (agent-at ?t2) (not (agent-at ?t1)))
 )
(:action pick-up
  :parameters (?i - inventory ?x - object ?t - tile)
  :precondition (and (agent-at ?t) (object-at ?x ?t) (inventory-empty ?i))
  :effect (and (inventory-holding ?i ?x) (not (object-at ?x ?t)) (not (inventory-empty ?i)))
 )
(:action place-down
  :parameters (?i - inventory ?x - object ?t - tile)
  :precondition (and (agent-at ?t) (inventory-holding ?i ?x))
  :effect (and (object-at ?x ?t) (not (inventory-holding ?i ?x)) (inventory-empty ?i))
 )
(:action mine-iron-ore
  :parameters (?toolinv - inventory ?targetinv - inventory ?x - object ?tool - object ?target - object ?t - tile)
  :precondition (and
    (agent-at ?t)
    (object-at ?x ?t)
    (object-of-type ?x IronOreVein)
    (inventory-holding ?toolinv ?tool)
    (object-of-type ?tool Pickaxe)
    (inventory-empty ?targetinv)
    (object-of-type ?target Hypothetical)
  )
  :effect (and
    (not (inventory-empty ?targetinv))
    (inventory-holding ?targetinv ?target)
    (not (object-of-type ?target Hypothetical))
    (object-of-type ?target IronOre)
  )
 )
(:action mine-wood_2
 :parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?x ?t)
   (object-of-type ?x Tree)
   (inventory-holding ?toolinv ?tool)
   (object-of-type ?tool Axe)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Wood)
 )
)
(:action mine-wool1_0
 :parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?x ?t)
   (object-of-type ?x Sheep)
   (inventory-holding ?toolinv ?tool)
   (object-of-type ?tool Shears)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Wool)
 )
)
(:action mine-potato_0
 :parameters (?t - tile ?x - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?x ?t)
   (object-of-type ?x PotatoPlant)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Potato)
 )
)
(:action mine-sugar-cane_2
 :parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?x ?t)
   (object-of-type ?x SugarCanePlant)
   (inventory-holding ?toolinv ?tool)
   (object-of-type ?tool Axe)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target SugarCane)
 )
)
(:action mine-beetroot_1
 :parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?x ?t)
   (object-of-type ?x BeetrootCrop)
   (inventory-holding ?toolinv ?tool)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Beetroot)
 )
)
(:action mine-feather_1
 :parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?x ?t)
   (object-of-type ?x Chicken)
   (inventory-holding ?toolinv ?tool)
   (object-of-type ?tool Sword)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Feather)
 )
)
(:action mine-cobblestone_2
 :parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?x ?t)
   (object-of-type ?x CobblestoneStash)
   (inventory-holding ?toolinv ?tool)
   (object-of-type ?tool Pickaxe)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Cobblestone)
 )
)
(:action mine-gold-ore1_2
 :parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?x ?t)
   (object-of-type ?x GoldOreVein)
   (inventory-holding ?toolinv ?tool)
   (object-of-type ?tool Pickaxe)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target GoldOre)
 )
)
(:action mine-coal1_0
 :parameters (?t - tile ?x - object ?toolinv - inventory ?tool - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?x ?t)
   (object-of-type ?x CoalOreVein)
   (inventory-holding ?toolinv ?tool)
   (object-of-type ?tool Pickaxe)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Coal)
 )
)
(:action mine-beetroot1_0
 :parameters (?t - tile ?x - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?x ?t)
   (object-of-type ?x BeetrootCrop)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Beetroot)
 )
)
(:action craft-wood-plank
  :parameters (?ingredientinv1 - inventory ?targetinv - inventory ?station - object ?ingredient1 - object ?target - object ?t - tile)
  :precondition (and
    (agent-at ?t)
    (object-at ?station ?t)
    (object-of-type ?station WorkStation)
    (inventory-holding ?ingredientinv1 ?ingredient1)
    (object-of-type ?ingredient1 Wood)
    (inventory-empty ?targetinv)
    (object-of-type ?target Hypothetical)
  )
  :effect (and
    (not (inventory-empty ?targetinv))
    (inventory-holding ?targetinv ?target)
    (not (object-of-type ?target Hypothetical))
    (object-of-type ?target WoodPlank)
    (not (inventory-holding ?ingredientinv1 ?ingredient1))
    (inventory-empty ?ingredientinv1)
    (not (object-of-type ?ingredient1 Wood))
    (object-of-type ?ingredient1 Hypothetical)
  )
 )
(:action craft-arrow
  :parameters (?ingredientinv1 - inventory ?ingredientinv2 - inventory ?targetinv - inventory ?station - object ?ingredient1 - object ?ingredient2 - object ?target - object ?t - tile)
  :precondition (and
    (agent-at ?t)
    (object-at ?station ?t)
    (object-of-type ?station WorkStation)
    (inventory-holding ?ingredientinv1 ?ingredient1)
    (object-of-type ?ingredient1 Stick)
    (inventory-holding ?ingredientinv2 ?ingredient2)
    (object-of-type ?ingredient2 Feather)
    (inventory-empty ?targetinv)
    (object-of-type ?target Hypothetical)
  )
  :effect (and
    (not (inventory-empty ?targetinv))
    (inventory-holding ?targetinv ?target)
    (not (object-of-type ?target Hypothetical))
    (object-of-type ?target Arrow)
    (not (inventory-holding ?ingredientinv1 ?ingredient1))
    (inventory-empty ?ingredientinv1)
    (not (object-of-type ?ingredient1 Stick))
    (object-of-type ?ingredient1 Hypothetical)
    (not (inventory-holding ?ingredientinv2 ?ingredient2))
    (inventory-empty ?ingredientinv2)
    (not (object-of-type ?ingredient2 Feather))
    (object-of-type ?ingredient2 Hypothetical)
  )
 )
(:action craft-beetroot-soup_0
 :parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?station ?t)
   (object-of-type ?station WorkStation)
   (inventory-holding ?ingredientinv1 ?ingredient1)
   (object-of-type ?ingredient1 Beetroot)
   (inventory-holding ?ingredientinv2 ?ingredient2)
   (object-of-type ?ingredient2 Bowl)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target BeetrootSoup)
   (not (inventory-holding ?ingredientinv1 ?ingredient1))
   (inventory-empty ?ingredientinv1)
   (not (object-of-type ?ingredient1 Beetroot))
   (object-of-type ?ingredient1 Hypothetical)
   (not (inventory-holding ?ingredientinv2 ?ingredient2))
   (inventory-empty ?ingredientinv2)
   (not (object-of-type ?ingredient2 Bowl))
   (object-of-type ?ingredient2 Hypothetical)
 )
)
(:action craft-paper_0
 :parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?station ?t)
   (object-of-type ?station WorkStation)
   (inventory-holding ?ingredientinv1 ?ingredient1)
   (object-of-type ?ingredient1 SugarCane)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Paper)
   (not (inventory-holding ?ingredientinv1 ?ingredient1))
   (inventory-empty ?ingredientinv1)
   (not (object-of-type ?ingredient1 SugarCane))
   (object-of-type ?ingredient1 Hypothetical)
 )
)
(:action craft-shears2_2
 :parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?station ?t)
   (object-of-type ?station WorkStation)
   (inventory-holding ?ingredientinv1 ?ingredient1)
   (object-of-type ?ingredient1 GoldIngot)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Shears)
   (not (inventory-holding ?ingredientinv1 ?ingredient1))
   (inventory-empty ?ingredientinv1)
   (not (object-of-type ?ingredient1 GoldIngot))
   (object-of-type ?ingredient1 Hypothetical)
 )
)
(:action craft-bowl_1
 :parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?station ?t)
   (object-of-type ?station WorkStation)
   (inventory-holding ?ingredientinv1 ?ingredient1)
   (object-of-type ?ingredient1 WoodPlank)
   (inventory-holding ?ingredientinv2 ?ingredient2)
   (object-of-type ?ingredient2 WoodPlank)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Bowl)
   (not (inventory-holding ?ingredientinv1 ?ingredient1))
   (inventory-empty ?ingredientinv1)
   (not (object-of-type ?ingredient1 WoodPlank))
   (object-of-type ?ingredient1 Hypothetical)
   (not (inventory-holding ?ingredientinv2 ?ingredient2))
   (inventory-empty ?ingredientinv2)
   (not (object-of-type ?ingredient2 WoodPlank))
   (object-of-type ?ingredient2 Hypothetical)
 )
)
(:action craft-boat_0
 :parameters (?t - tile ?station - object ?ingredientinv - inventory ?ingredient - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?station ?t)
   (object-of-type ?station WorkStation)
   (inventory-holding ?ingredientinv ?ingredient)
   (object-of-type ?ingredient WoodPlank)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Boat)
   (not (inventory-holding ?ingredientinv ?ingredient))
   (inventory-empty ?ingredientinv)
   (not (object-of-type ?ingredient WoodPlank))
   (object-of-type ?ingredient Hypothetical)
 )
)
(:action craft-cooked-potato_1
 :parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?station ?t)
   (object-of-type ?station WorkStation)
   (inventory-holding ?ingredientinv1 ?ingredient1)
   (object-of-type ?ingredient1 Potato)
   (inventory-holding ?ingredientinv2 ?ingredient2)
   (object-of-type ?ingredient2 Coal)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target CookedPotato)
   (not (inventory-holding ?ingredientinv1 ?ingredient1))
   (inventory-empty ?ingredientinv1)
   (not (object-of-type ?ingredient1 Potato))
   (object-of-type ?ingredient1 Hypothetical)
   (not (inventory-holding ?ingredientinv2 ?ingredient2))
   (inventory-empty ?ingredientinv2)
   (not (object-of-type ?ingredient2 Coal))
   (object-of-type ?ingredient2 Hypothetical)
 )
)
(:action craft-gold-ingot_1
 :parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?station ?t)
   (object-of-type ?station WorkStation)
   (inventory-holding ?ingredientinv1 ?ingredient1)
   (object-of-type ?ingredient1 GoldOre)
   (inventory-holding ?ingredientinv2 ?ingredient2)
   (object-of-type ?ingredient2 Coal)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target GoldIngot)
   (not (inventory-holding ?ingredientinv1 ?ingredient1))
   (inventory-empty ?ingredientinv1)
   (not (object-of-type ?ingredient1 GoldOre))
   (object-of-type ?ingredient1 Hypothetical)
   (not (inventory-holding ?ingredientinv2 ?ingredient2))
   (inventory-empty ?ingredientinv2)
   (not (object-of-type ?ingredient2 Coal))
   (object-of-type ?ingredient2 Hypothetical)
 )
)
(:action craft-stick_0
 :parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?station ?t)
   (object-of-type ?station WorkStation)
   (inventory-holding ?ingredientinv1 ?ingredient1)
   (object-of-type ?ingredient1 WoodPlank)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Stick)
   (not (inventory-holding ?ingredientinv1 ?ingredient1))
   (inventory-empty ?ingredientinv1)
   (not (object-of-type ?ingredient1 WoodPlank))
   (object-of-type ?ingredient1 Hypothetical)
 )
)
(:action craft-sword_0
 :parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?station ?t)
   (object-of-type ?station WorkStation)
   (inventory-holding ?ingredientinv1 ?ingredient1)
   (object-of-type ?ingredient1 Stick)
   (inventory-holding ?ingredientinv2 ?ingredient2)
   (object-of-type ?ingredient2 IronIngot)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Sword)
   (not (inventory-holding ?ingredientinv1 ?ingredient1))
   (inventory-empty ?ingredientinv1)
   (not (object-of-type ?ingredient1 Stick))
   (object-of-type ?ingredient1 Hypothetical)
   (not (inventory-holding ?ingredientinv2 ?ingredient2))
   (inventory-empty ?ingredientinv2)
   (not (object-of-type ?ingredient2 IronIngot))
   (object-of-type ?ingredient2 Hypothetical)
 )
)
(:action craft-bed_1
 :parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?station ?t)
   (object-of-type ?station WorkStation)
   (inventory-holding ?ingredientinv1 ?ingredient1)
   (object-of-type ?ingredient1 WoodPlank)
   (inventory-holding ?ingredientinv2 ?ingredient2)
   (object-of-type ?ingredient2 Wool)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target Bed)
   (not (inventory-holding ?ingredientinv1 ?ingredient1))
   (inventory-empty ?ingredientinv1)
   (not (object-of-type ?ingredient1 WoodPlank))
   (object-of-type ?ingredient1 Hypothetical)
   (not (inventory-holding ?ingredientinv2 ?ingredient2))
   (inventory-empty ?ingredientinv2)
   (not (object-of-type ?ingredient2 Wool))
   (object-of-type ?ingredient2 Hypothetical)
 )
)
(:action craft-iron-ingot_2
 :parameters (?t - tile ?station - object ?ingredientinv1 - inventory ?ingredient1 - object ?ingredientinv2 - inventory ?ingredient2 - object ?targetinv - inventory ?target - object)

 :precondition (and 
   (agent-at ?t)
   (object-at ?station ?t)
   (object-of-type ?station WorkStation)
   (inventory-holding ?ingredientinv1 ?ingredient1)
   (object-of-type ?ingredient1 IronOre)
   (inventory-holding ?ingredientinv2 ?ingredient2)
   (object-of-type ?ingredient2 Coal)
   (inventory-empty ?targetinv)
   (object-of-type ?target Hypothetical)
 )
 :effect (and 
   (not (inventory-empty ?targetinv))
   (inventory-holding ?targetinv ?target)
   (not (object-of-type ?target Hypothetical))
   (object-of-type ?target IronIngot)
   (not (inventory-holding ?ingredientinv1 ?ingredient1))
   (inventory-empty ?ingredientinv1)
   (not (object-of-type ?ingredient1 IronOre))
   (object-of-type ?ingredient1 Hypothetical)
   (not (inventory-holding ?ingredientinv2 ?ingredient2))
   (inventory-empty ?ingredientinv2)
   (not (object-of-type ?ingredient2 Coal))
   (object-of-type ?ingredient2 Hypothetical)
 )
)
)
Original ALFRED PDDL library
(define (domain alfred)
    (:requirements :adl
    )
    (:types
        agent location receptacle object rtype otype
    )
    (:constants
        CandleType - otype
        ShowerGlassType - otype
        CDType - otype
        TomatoType - otype
        MirrorType - otype
        ScrubBrushType - otype
        MugType - otype
        ToasterType - otype
        PaintingType - otype
        CellPhoneType - otype
        LadleType - otype
        BreadType - otype
        PotType - otype
        BookType - otype
        TennisRacketType - otype
        ButterKnifeType - otype
        ShowerDoorType - otype
        KeyChainType - otype
        BaseballBatType - otype
        EggType - otype
        PenType - otype
        ForkType - otype
        VaseType - otype
        ClothType - otype
        WindowType - otype
        PencilType - otype
        StatueType - otype
        LightSwitchType - otype
        WatchType - otype
        SpatulaType - otype
        PaperTowelRollType - otype
        FloorLampType - otype
        KettleType - otype
        SoapBottleType - otype
        BootsType - otype
        TowelType - otype
        PillowType - otype
        AlarmClockType - otype
        PotatoType - otype
        ChairType - otype
        PlungerType - otype
        SprayBottleType - otype
        HandTowelType - otype
        BathtubType - otype
        RemoteControlType - otype
        PepperShakerType - otype
        PlateType - otype
        BasketBallType - otype
        DeskLampType - otype
        FootstoolType - otype
        GlassbottleType - otype
        PaperTowelType - otype
        CreditCardType - otype
        PanType - otype
        ToiletPaperType - otype
        SaltShakerType - otype
        PosterType - otype
        ToiletPaperRollType - otype
        LettuceType - otype
        WineBottleType - otype
        KnifeType - otype
        LaundryHamperLidType - otype
        SpoonType - otype
        TissueBoxType - otype
        BowlType - otype
        BoxType - otype
        SoapBarType - otype
        HousePlantType - otype
        NewspaperType - otype
        CupType - otype
        DishSpongeType - otype
        LaptopType - otype
        TelevisionType - otype
        StoveKnobType - otype
        CurtainsType - otype
        BlindsType - otype
        TeddyBearType - otype
        AppleType - otype
        WateringCanType - otype
        SinkType - otype

        ArmChairType - rtype
        BedType - rtype
        BathtubBasinType - rtype
        DresserType - rtype
        SafeType - rtype
        DiningTableType - rtype
        SofaType - rtype
        HandTowelHolderType - rtype
        StoveBurnerType - rtype
        CartType - rtype
        DeskType - rtype
        CoffeeMachineType - rtype
        MicrowaveType - rtype
        ToiletType - rtype
        CounterTopType - rtype
        GarbageCanType - rtype
        CoffeeTableType - rtype
        CabinetType - rtype
        SinkBasinType - rtype
        OttomanType - rtype
        ToiletPaperHangerType - rtype
        TowelHolderType - rtype
        FridgeType - rtype
        DrawerType - rtype
        SideTableType - rtype
        ShelfType - rtype
        LaundryHamperType - rtype

    )
    ;; Predicates defined on this domain. Note the types for each predicate.
(:predicates
	(atLocation ?a - agent ?l - location) 
        (receptacleAtLocation ?r - receptacle ?l - location) 
        (objectAtLocation ?o - object ?l - location)
        (inReceptacle ?o - object ?r - receptacle) 
        (receptacleType ?r - receptacle ?t - rtype) 
        (objectType ?o - object ?t - otype) 
        (holds ?a - agent ?o - object) 
        (holdsAny ?a - agent) 
        (holdsAnyReceptacleObject ?a - agent) 
        
	    (openable ?r - receptacle) 
        (opened ?r - receptacle) 
        (isClean ?o - object) 
        (cleanable ?o - object) 
        (isHot ?o - object) 
        (heatable ?o - object) 
        (isCool ?o - object) 
        (coolable ?o - object) 
        (toggleable ?o - object)  
        (isToggled ?o - object) 
        (sliceable ?o - object) 
        (isSliced ?o - object) 
 )
(:action PickupObjectNotInReceptacle
        :parameters (?a - agent ?l - location ?o - object)
        :precondition (and
            (atLocation ?a ?l)
            (objectAtLocation ?o ?l)
            (not (holdsAny ?a))
            (forall
                (?re - receptacle)
                (not (inReceptacle ?o ?re))
            )
        )
        :effect (and
            (not (objectAtLocation ?o ?l))
            (holds ?a ?o)
            (holdsAny ?a)
        )
    )

(:action PutObjectInReceptacle
        :parameters (?a - agent ?l - location ?ot - otype ?o - object ?r - receptacle)
        :precondition (and
            (atLocation ?a ?l)
            (receptacleAtLocation ?r ?l)
            (objectType ?o ?ot)
            (holds ?a ?o)
            (not (holdsAnyReceptacleObject ?a))
        )
        :effect (and
            (inReceptacle ?o ?r)
            (not (holds ?a ?o))
            (not (holdsAny ?a))
            (objectAtLocation ?o ?l)
        )
    )
    
(:action PickupObjectInReceptacle
        :parameters (?a - agent ?l - location ?o - object ?r - receptacle)
        :precondition (and
            (atLocation ?a ?l)
            (objectAtLocation ?o ?l)
            (inReceptacle ?o ?r)
            (not (holdsAny ?a))
        )
        :effect (and
            (not (objectAtLocation ?o ?l))
            (not (inReceptacle ?o ?r))
            (holds ?a ?o)
            (holdsAny ?a)
        )
    )

    (:action RinseObject_2
        :parameters (?toolreceptacle - receptacle ?a - agent ?l - location ?o - object)

        :precondition (and 
		(receptacleType ?toolreceptacle SinkBasinType)
		(atLocation ?a ?l)
		(receptacleAtLocation ?toolreceptacle ?l)
		(objectAtLocation ?o ?l)
		(cleanable ?o)
		)
        :effect (and 
		(isClean ?o)
		)
)

(:action TurnOnObject_2
        :parameters (?a - agent ?l - location ?o - object)

        :precondition (and 
		(atLocation ?a ?l)
		(objectAtLocation ?o ?l)
		(toggleable ?o)
		)
        :effect (and 
		(isToggled ?o)
		)
)

(:action CoolObject_0
        :parameters (?toolreceptacle - receptacle ?a - agent ?l - location ?o - object)

        :precondition (and 
		(receptacleType ?toolreceptacle FridgeType)
		(atLocation ?a ?l)
		(receptacleAtLocation ?toolreceptacle ?l)
		(holds ?a ?o)
		)
        :effect (and 
		(isCool ?o)
		)
)
(:action SliceObject_1
        :parameters (?toolobject - object ?a - agent ?l - location ?o - object)

        :precondition (and 
		(objectType ?toolobject ButterKnifeType)
		(atLocation ?a ?l)
		(objectAtLocation ?o ?l)
		(sliceable ?o)
		(holds ?a ?toolobject)
		)
        :effect (and 
		(isSliced ?o)
		)
)
(:action SliceObject_0
        :parameters (?toolobject - object ?a - agent ?l - location ?o - object)

        :precondition (and 
		(objectType ?toolobject KnifeType)
		(atLocation ?a ?l)
		(objectAtLocation ?o ?l)
		(sliceable ?o)
		(holds ?a ?toolobject)
		)
        :effect (and 
		(isSliced ?o)
		)
)
(:action MicrowaveObject_0
        :parameters (?toolreceptacle - receptacle ?a - agent ?l - location ?o - object)

        :precondition (and 
		(receptacleType ?toolreceptacle MicrowaveType)
		(atLocation ?a ?l)
		(receptacleAtLocation ?toolreceptacle ?l)
		(holds ?a ?o)
		)
        :effect (and 
		(isHot ?o)
		)
)

)
Concept demonstration

Open image ↗