Hierarchical Task Planning

The fundamental mechanism where a high-level abstract goal is recursively broken down into a tree of concrete sub-tasks or primitive skills. This creates a hierarchical plan where each node represents a task, and its children are the steps required to complete it. For example, the instruction 'Make coffee' decomposes to: 1. Navigate to kitchen, 2. Find coffee machine, 3. Add water, 4. Add coffee grounds, 5. Press start. Lower levels handle sensorimotor execution, while higher levels manage symbolic reasoning and recovery from failure.

HTP typically operates in a hybrid symbolic-subsymbolic paradigm. The high-level planner uses symbolic representations (e.g., predicates like on(cup, table), graspable(mug)) and classical planning algorithms (like PDDL-based solvers) to sequence tasks. These symbolic actions are 'grounded' by calling learned neural network policies or low-level controllers that execute the actual sensorimotor control. This separation allows for logical verification at the high level and robust execution at the low level.

A robust HTP system continuously monitors preconditions and postconditions for each task in the hierarchy. If a precondition fails (e.g., an object is not where expected) or an action's execution fails, the system triggers replanning. This can be:

• Local repair: Replanning from the failed node downward.
• Global replanning: Re-evaluating the entire task tree.
• Skill substitution: Selecting an alternative low-level skill to achieve the same symbolic effect. This closed-loop feedback is critical for operating in dynamic, real-world environments.

Modern HTP often uses Large Language Models (LLMs) as the high-level symbolic planner. The LLM's ability to parse natural language and reason about commonsense steps is leveraged for task decomposition. Frameworks like Google's SayCan exemplify this: the LLM ('Say') proposes plausible next steps, which are filtered by an affordance model ('Can') that predicts the probability of success for each low-level skill. This creates a language-conditioned plan that is both semantically correct and physically feasible.

A key advantage of HTP is the creation of a library of reusable skills. Low-level skills (e.g., Pick(object), Place(object, location), NavigateTo(room)) are trained or programmed once and can be composed in countless ways by different high-level plans. This promotes efficient development and systematic generalization. New complex tasks can often be achieved by simply creating a new high-level plan that sequences existing skills, without retraining the underlying motor policies.

The hierarchical plan enforces temporal ordering (sequence, parallelism) and causal dependencies between tasks. These constraints ensure the plan is physically consistent. For instance, Pour(water, cup) must occur after Grasp(pitcher) and requires the precondition Contains(pitcher, water). The planner must resolve resource conflicts (e.g., the robot's single end-effector) and may introduce intermediate sub-goals (e.g., MoveToSide(table) to clear space) to satisfy all constraints for a feasible plan.

A Vision-Language-Action (VLA) model is the multimodal AI architecture that often serves as the low-level executor in a hierarchical planning stack. It directly processes raw visual observations and a language sub-task command to generate low-level robot actions (e.g., joint velocities, gripper commands). Unlike a pure planner, a VLA model closes the perception-action loop by translating intent into motion. Examples include RT-2 and PaLM-E, which are trained on large-scale embodied datasets.

A language-conditioned policy is a control function, typically a neural network, that maps the current environmental state and a natural language instruction directly to an action. This represents an alternative, less hierarchical approach to the instruction-to-action problem. Key characteristics include:

• End-to-End Learning: Often trained via imitation learning or reinforcement learning.
• Monolithic Architecture: May not explicitly decompose long-horizon tasks.
• Scalability Challenge: Can struggle with tasks requiring long sequences of distinct skills compared to hierarchical methods.

The SayCan paradigm is a seminal robotics framework that explicitly separates high-level planning from low-level feasibility, embodying the core principle of hierarchical planning. It combines:

• 'Say': A large language model's ability to decompose instructions into a logical sequence of sub-tasks.
• 'Can': An affordance model that scores the probability of success for each proposed skill given the current visual scene. The system executes the sequence with the highest combined linguistic and feasibility score, ensuring plans are both logical and executable.

Affordance prediction is the perceptual task of identifying how and where an object or scene can be interacted with. It is a critical input for hierarchical planners and skill libraries. The output is often a spatial map highlighting regions for potential actions (e.g., grasp points, push directions, pour locations). This bridges visual grounding (what is 'the mug') with actionable intelligence (where to grasp it), informing which low-level skills are viable for a given sub-task.

Embodied Question Answering (EQA) is an evaluation task and capability closely related to hierarchical planning. An agent receives a question (e.g., 'What color is the car in the garage?') that cannot be answered from its initial viewpoint. The agent must:

• Plan a sequence of navigation and/or interaction sub-tasks to gather necessary information.
• Act to execute that plan.
• Answer the question based on acquired perceptions. It tests an agent's ability to link language, perception, and action planning over time.

A skill library or behavior repository is the curated set of low-level, reusable primitive actions or short-horizon policies that a hierarchical task planner selects from and sequences. These skills are the building blocks of complex behavior. They are often:

• Pre-defined: Engineered robust controllers (e.g., 'pick', 'place', 'open drawer').
• Learned: Trained via imitation learning or reinforcement learning in simulation or the real world.
• Parameterized: Can be conditioned on object poses or other scene properties.