AtomTree: A Hierarchical Framework Making LLM Embodied Planning More Robust

Introduction

Embodied agents that execute natural language instructions in interactive environments need to understand human intent and complete long-horizon tasks. Traditional methods either rely on large amounts of annotated trajectories or use few-shot/zero-shot LLM prompting to generate a complete plan in one shot. This "one-shot planning" paradigm relies heavily on linguistic common sense, locks in the plan from the initial instruction, and only updates after failure, resulting in insufficient robustness and state awareness. The recently proposed AtomTree framework offers a new approach to LLM-driven embodied planning through hierarchical and state-aware mechanisms.

Limitations of Existing Planning

Existing embodied instruction-following planners fall mainly into two categories: one based on supervised learning from large-scale annotated trajectories, which has high generalization costs; the other leveraging the few-shot or zero-shot capabilities of LLMs to generate a complete action sequence through a single serial inference pass. Although the latter reduces data dependence, it has obvious flaws: the planning process is disconnected from the current environment state, and the LLM can only "fill in" execution details based on linguistic common sense; once the initial plan is wrong, the agent can only re-plan after an action fails, by which point it may have drifted far from the goal. This "open-loop" characteristic makes agents fragile in dynamic or uncertain environments.

Symbolic state is a key concept in embodied planning. It refers to using discrete, structured symbols (such as predicate logic, key-value pairs, or scene graphs) to abstractly represent environment information, such as object categories, spatial relationships, objects held by the agent, and container open/closed states. Compared with raw pixels or sensor data, symbolic state greatly compresses the amount of information, enabling large language models to focus on decision-relevant elements within a limited context window. In classical planning, symbolic state is the input to search algorithms; in LLM-driven embodied planning, symbolic state serves as the interface between the language model and the environment—the LLM reasons about the next action based on symbolic descriptions, and after execution the perception module updates the symbolic state. The design of symbolic state directly affects the interpretability and accuracy of planning: too coarse a granularity loses key constraints, while too fine a granularity increases the LLM's reasoning burden.

Open-loop planning and closed-loop planning are contrasting frameworks for understanding the flaws of one-shot planning. Open-loop control refers to a system executing actions according to a preset sequence without adjusting based on execution results, akin to cooking from a fixed recipe; closed-loop control continuously collects feedback and corrects subsequent actions. LLM one-shot generation of a complete plan is a typical open-loop pattern: the plan is frozen the moment it is generated, and environmental changes or reasoning errors during execution cannot be corrected in time. Closed-loop planning requires evaluating state deviations after each action and re-deciding, but the cost is the computational overhead and context bloat from frequent LLM calls. AtomTree's incremental decision-making is essentially a compromise between the two: it retains the LLM's reasoning capability while introducing closed-loop feedback through state awareness and backtracking re-planning, thereby striking a balance between robustness and efficiency.

AtomTree's Core Design

AtomTree models task planning as an incrementally constructed tree of subgoals and actions. At each step, the LLM decides based on the current symbolic state whether to further decompose a subgoal or directly output an executable low-level action. This "on-demand decomposition" strategy avoids prematurely locking in an abstract plan, allowing the planning granularity to adjust dynamically with environmental feedback.

State-Aware Decision-Making

Unlike one-shot generation of a full plan, AtomTree makes decisions at each step based on the latest symbolic state. Symbolic state abstracts key information in the environment (such as object positions and agent state), enabling the LLM to focus on currently actionable choices. This design gives the planning process inherent state awareness and reduces errors caused by deviations in linguistic common sense.

Lightweight Memory Module

AtomTree introduces a lightweight memory module that summarizes the execution results of past subgoals. These summaries are reused in subsequent decisions, helping the LLM avoid repeating mistakes or leverage acquired experience. The memory module does not store raw trajectories but distills key information, reducing context length pressure.

Hierarchical Backtracking Re-planning

When low-level action execution stalls, AtomTree triggers hierarchical backtracking re-planning: it returns to the parent node and regenerates the subtree plan based on the latest state. This mechanism prevents the agent from continuing to drift along an erroneous trajectory, turning failure into an opportunity for local re-planning rather than a global restart. The hierarchical structure of backtracking keeps the scope of re-planning controllable, improving robustness on long-horizon tasks.

Zero-Shot Evaluation Performance

In zero-shot evaluation on the ALFRED benchmark, AtomTree outperforms previous LLM-based planners. ALFRED is a common testbed for embodied instruction following, requiring agents to complete multi-step tasks in simulated household environments. The zero-shot setting means AtomTree was not fine-tuned on this benchmark, and its advantage stems from the framework design itself. This result shows that combining hierarchy with state awareness can effectively improve the generalization capability of LLMs in embodied planning.

ALFRED (Action Learning From Realistic Environments and Directives) is a representative benchmark in the field of embodied instruction following, proposed by Shridhar et al. in 2020. It is built on the AI2-THOR simulator and contains about 25,000 natural language instructions covering multi-step tasks in household environments, such as "put the heated apple in the refrigerator." ALFRED's difficulty lies in the long-horizon nature of tasks, instructions involving spatial and state constraints, and the requirement for agents to perform multiple types of actions such as navigation, object manipulation, and state changes. Evaluation typically uses metrics such as Success Rate and path-weighted success rate. Zero-shot evaluation means the model is not fine-tuned on the ALFRED training set and is tested directly for generalization, thus better reflecting the merits of the framework design itself rather than fitting to a specific data distribution.

Implications for Embodied Intelligence

AtomTree reflects a trend in embodied planning: moving from "one-shot generation" to "incremental decision-making." By combining the LLM's reasoning capability with the real-time state of the environment, agents can respond more flexibly to uncertainty. The hierarchical backtracking mechanism also provides a structured solution for error recovery, avoiding the high cost of traditional re-planning. In the future, how to represent symbolic state more efficiently and how to adapt the memory module to more complex tasks remain directions worth exploring.

One-line Summary

AtomTree achieves state-aware LLM embodied planning through an incremental subgoal and action tree, surpassing baselines in zero-shot settings.

Paragraph Summary

AtomTree is an LLM planning framework for embodied instruction following, designed to overcome the open-loop flaws of traditional one-shot planning. It models task planning as an incrementally constructed tree of subgoals and actions: at each step, the LLM decides based on the current symbolic state whether to continue decomposing subgoals or output low-level actions, thereby avoiding prematurely locking in an abstract plan. The framework introduces a lightweight memory module that summarizes the execution results of historical subgoals to assist subsequent decisions, and triggers hierarchical backtracking re-planning when low-level actions stall, returning to the parent node to regenerate the subtree based on the latest state and turning failure into local adjustment. In zero-shot evaluation on the ALFRED benchmark, AtomTree outperforms previous LLM-based planners, demonstrating that combining hierarchy with state awareness can effectively improve generalization and robustness on long-horizon tasks.