Sub-task Planner: Hierarchical Task Decomposition

• Sub-task Planner (SP) is a framework that decomposes complex, long-horizon goals into manageable subgoals, addressing both contextual and logical gaps.
• It employs hierarchical and graph-based subgoal trees to translate high-level natural language instructions into executable low-level actions.
• Empirical results in simulated and real-world environments demonstrate that SP architectures notably improve success rates over end-to-end planning models.

A Sub-task Planner (SP) is a core architectural and algorithmic component in intelligent systems tasked with decomposing complex, long-horizon goals into manageable, actionable subgoals or atomic actions. In robotics, embodied AI, automated agents, and multi-task reasoning, the SP addresses key contextual and logical challenges by explicitly structuring planning through hierarchical, graph-based, or sequential sub-task generation. SPs facilitate efficient reasoning, exploit modularity, and bridge the high-level specification of goals with low-level action primitives, substantially improving the feasibility and reliability of task-oriented agents in complex real-world and simulated environments.

1. Formal Motivations: Addressing Contextual and Logical Gaps

Sub-task planning emerges in response to two principal deficiencies in naïve end-to-end sequence generation for long-horizon tasks. First, the contextual gap arises when models must attend to extensive histories of observations and actions; as this context increases with task length, attention coherence degrades and planning success decreases. Second, the logical gap refers to the inherent abstraction mismatch between high-level natural language instructions and low-level action spaces (e.g., “clean the table” vs. “move to $(x, y, z)$; actuate gripper). Direct mapping often exceeds the reasoning ability of current models, particularly LLMs.

To formally define the problem, let $S$ denote the (possibly partially observed) state space, $A$ the set of available primitive actions, and $G$ the high-level goal specified in natural language. The planner’s mandate is to yield a sequence $a_0: a_n$ such that, under the transition dynamics $T$, the terminal state $s_n$ satisfies $G$:

$$G \implies \{g_1, ..., g_K\},\quad g_i \implies \text{action sequence achieving } g_i,$$

where $g_i$ are intermediate subgoals whose union implies $G$ (Tianxing et al., 26 Jun 2025). Subgoal decomposition thus transforms solving $G$ into sequentially or hierarchically achieving a set of tractable subgoals.

2. Hierarchical and Cross-Hierarchical Subgoal Tree Formalisms

A canonical approach in SP design is to represent task decomposition as a tree structure, $\mathcal{T} = (\mathcal{V}, \mathcal{E})$, where each node $v\in\mathcal{V}$ corresponds to a subgoal and edges encode refinement or decomposition relationships. The root node $v_0$ represents the original high-level goal, and leaf nodes map directly to primitive actions or short action macros.

The tree grows recursively:

• At each non-leaf node, a subgoal decomposition model (typically an LLM, possibly foundation scale) generates $k$ child subgoals by conditioning on the parent subgoal $G_{\mathrm{parent}}$, subtask history $h$, and the current observation $o_t$.
• At each candidate leaf, a termination model (which may consist of affordance or policy checks) evaluates mappability (whether a subgoal can be directly executed in the current state) and consistency (whether such execution respects all embodiment constraints and prior subgoal dependencies):

$\tau(s_t, g) = \begin{cases} 1 & \text{if %%%%19%%%% is mappable to a primitive and consistent} \ 0 & \text{otherwise} \end{cases}$

Assembling the final plan involves traversing this coarse-to-fine tree until all leaves are directly executable. This hierarchical approach reduces the length and abstraction gap handled by any single LLM decision, cutting the context window and making planning tractable for long-horizon embodied tasks (Tianxing et al., 26 Jun 2025).

3. Algorithmic Pipeline

The standard SP pipeline implementing cross-hierarchical subgoal trees includes:

1. Initialization: Start with root subgoal $g^{(0)} = G$.
2. Iterative Expansion:

While non-leaf nodes exist, for each: - Invoke subgoal decomposition to produce children. - For each child, evaluate the leaf termination function. - Mark children as leaf or expandable.

1. Execution or Further Decomposition: If a node is executable, convert to action; otherwise, recurse.

The core recursive procedures can be outlined as:

Function BuildSubgoalTree(G): T ← tree with root G While exists non-leaf g in T: If LeafNodeCheck(s_t, g) == EXECUTE: execute action for g mark g as leaf Else: children ← SubgoalDecompose(g, s_t) attach children to T Return T

This pipeline tightly couples model-based proposal (LLM), closed-loop affordance evaluation, and coarse-to-fine exploration, leveraging environmental feedback at each iteration.

4. Benchmarking and Empirical Performance

STEP—a reference cross-hierarchical SP framework—was extensively evaluated on two settings:

• VirtualHome WAH-NL: 100 NL tasks in dense household scenes.
• Real robot: Franka Panda + RoboScript API.

Performance metrics include:

• SR (Success Rate): Proportion of tasks where all subgoals are completed.
• SSR (Subgoal Success Rate): Fraction of subgoals individually completed.

Key empirical findings:

• WAH-NL: STEP achieved 34% SR, surpassing prior SOTA baselines (6%–12%) by a large margin.
• Real robot: SR ≈ 25% on complex long-horizon tasks, substantially outperforming SayCan, LoTa-Bench, and ProgPrompt by factors of 2–5 (Tianxing et al., 26 Jun 2025).

These results provide quantitative evidence that hierarchical SP architectures substantially raise the ceiling for long-horizon embodied planning compared to single-shot LLM or monolithic planners.

5. Advantages, Limitations, and Open Questions

Strengths:

• Continuous focus on subgoals minimizes context explosion and isolates each LLM invocation to a local, more easily interpretable decision problem.
• Hierarchical bridging enables robust translation from high-level NL instructions to executable embodied actions.
• Closed-loop feedback at every termination check ensures that environmental dynamics—often highly stochastic in deployment—directly moderate the plan structure.
• Significantly higher reliability, as descent through refinement trees prunes many spurious or redundant actions by design.

Limitations and Challenges:

• Subgoal termination and affordance checking remain major sources of error, typically manifesting as extra or missing steps when misaligned with the embodiment’s true constraints.
• The approach, while mitigating context window size, may struggle to scale to extremely deep trees as required by ultra-long-horizon tasks.
• There exists an inherent dependency on the LLM’s ability to reason about affordances and environmental state, which can bottleneck performance if the domain or goal is far out-of-distribution for the underlying model.

Open Directions:

• Incorporating learned subgoal generators or evaluators to supplant or augment model-prompted decomposition.
• Integrating visual-LLMs for richer and more accurate perceptual grounding at the leaf termination stage.
• Meta-learning approaches to dynamically adjust decomposition depth and branching factor based on task domain and observed execution characteristics (Tianxing et al., 26 Jun 2025).

6. Role within Contemporary Embodied and Hierarchical Planning

The SP formalism, exemplified by STEP, crystallizes a best-practice template for embodied long-horizon planning: recursively decompose, interleave high-level semantic reasoning with environmental feedback, and always bridge every abstraction level before attempting execution. This aligns directionally with trends in state-dependency-aware adaptive planners (Shen et al., 30 Sep 2025), retrieval-driven demonstration partitioning (Yan et al., 16 Oct 2025), and the integration of logic-guided reasoning layers into high-throughput LLM-driven planning pipelines.

In sum, the Sub-task Planner—by formalizing and operationalizing hierarchical task decomposition—serves as a structuring backbone for robust, scalable, and generalizable long-horizon embodied planning across a growing array of embodied AI domains.