SDA-PLANNER: State-Dependency Aware Adaptive Planner

• SDA-PLANNER is an embodied planning framework that augments LLM-based planning with explicit action-state dependency modeling and adaptive, error-aware replanning.
• It employs a State-Dependency Graph to explicitly encode action preconditions and effects, ensuring valid mid-level action sequencing in dynamic environments.
• Empirical evaluation on ALFRED demonstrates improved Success and Goal Condition rates over baselines, validating its closed-loop error recovery and adaptive planning approach.

Searching arXiv for the main paper and closely related embodied planning work. SDA-PLANNER—short for State-Dependency Aware Adaptive Planner—is an embodied task-planning framework that augments LLM-based planning with explicit action-state dependency modeling and localized error-aware replanning. It targets the setting in which a natural-language instruction must be translated into an executable mid-level action sequence and executed in a closed loop within a dynamic environment. The framework is motivated by three limitations identified in prior LLM-based embodied planners: fixed planning paradigms, lack of action-sequence constraints, and error-agnostic replanning. Its central mechanism is a State-Dependency Graph that encodes action preconditions and effects, together with an Error Backtrack and Diagnosis module and an Adaptive Action SubTree Generation module for local plan repair (Shen et al., 30 Sep 2025).

1. Problem setting and planning objective

SDA-PLANNER studies embodied task planning in the form of instruction-conditioned action synthesis over a set of executable mid-level skills. The instruction $\mathcal{I}$ is decomposed into a mid-level action plan

$$\mathcal{P} =\{\mathcal{A}_0,\cdots,\mathcal{A}_t\}= \{(a_0, o_0),\cdots,(a_t, o_t)\},$$

where $a_t \in \mathcal{V}$ is an action type from the skill set $\mathcal{V}$, $o_t$ is the target object, and $(a_t,o_t)$ is the mid-level action (Shen et al., 30 Sep 2025).

The formulation emphasizes that embodied execution is closed-loop: the environment may differ from the planner’s assumptions, and actions can fail during rollout. Within that setting, the paper characterizes prior LLM-based planners as typically belonging to one of two categories. Iterative planners generate one action at a time from feedback and are adaptive but expensive in time and tokens. Tree planners construct a full action tree in advance and are more efficient than pure step-by-step generation, but their structure is fixed and adaptation after environmental change or execution error is limited (Shen et al., 30 Sep 2025).

A closely related line of work is AdaPlanner, which also argues that static or greedy planning is inadequate for long-horizon sequential decision-making and introduces explicit feedback-driven plan revision. Its distinction between in-plan refinement and out-of-plan refinement similarly treats plan repair as more than immediate action correction, but it does not center the repair process on an explicit precondition-effect graph (Sun et al., 2023).

2. State-Dependency Graph and symbolic action constraints

The core abstraction in SDA-PLANNER is the State-Dependency Graph $\mathcal{G}$, introduced to make action ordering constraints explicit. For each action $a \in \mathcal{V}$, the framework defines an effect set $\mathcal{S}_{\text{eff}[a]$ and a dependency set $\mathcal{S}_{\text{dep}[a]$. Each state is represented as a pair consisting of a state variable and its expected value, and the paper distinguishes agent states and item states, which are grounded to concrete objects when the action becomes a specific mid-level action $$\mathcal{P} =\{\mathcal{A}_0,\cdots,\mathcal{A}_t\}= \{(a_0, o_0),\cdots,(a_t, o_t)\},$$0 (Shen et al., 30 Sep 2025).

The graph itself is a directed bipartite graph with action nodes $$\mathcal{P} =\{\mathcal{A}_0,\cdots,\mathcal{A}_t\}= \{(a_0, o_0),\cdots,(a_t, o_t)\},$$1 and state nodes $$\mathcal{P} =\{\mathcal{A}_0,\cdots,\mathcal{A}_t\}= \{(a_0, o_0),\cdots,(a_t, o_t)\},$$2. A directed edge $$\mathcal{P} =\{\mathcal{A}_0,\cdots,\mathcal{A}_t\}= \{(a_0, o_0),\cdots,(a_t, o_t)\},$$3 means that action $$\mathcal{P} =\{\mathcal{A}_0,\cdots,\mathcal{A}_t\}= \{(a_0, o_0),\cdots,(a_t, o_t)\},$$4 modifies state $$\mathcal{P} =\{\mathcal{A}_0,\cdots,\mathcal{A}_t\}= \{(a_0, o_0),\cdots,(a_t, o_t)\},$$5, and the edge is annotated with the resulting value $$\mathcal{P} =\{\mathcal{A}_0,\cdots,\mathcal{A}_t\}= \{(a_0, o_0),\cdots,(a_t, o_t)\},$$6. A directed edge $$\mathcal{P} =\{\mathcal{A}_0,\cdots,\mathcal{A}_t\}= \{(a_0, o_0),\cdots,(a_t, o_t)\},$$7 means that action $$\mathcal{P} =\{\mathcal{A}_0,\cdots,\mathcal{A}_t\}= \{(a_0, o_0),\cdots,(a_t, o_t)\},$$8 requires state $$\mathcal{P} =\{\mathcal{A}_0,\cdots,\mathcal{A}_t\}= \{(a_0, o_0),\cdots,(a_t, o_t)\},$$9 to have value $a_t \in \mathcal{V}$0 before execution. In operational terms, $a_t \in \mathcal{V}$1 supplies the missing action-sequence constraints that are often absent from unconstrained LLM plans, such as the requirement that a state enabling “place tomato” must be established before the action is proposed (Shen et al., 30 Sep 2025).

The paper allows the state sets to be built either by querying an LLM for commonsense annotations or by using an external task-specific knowledge base. In the LLM-based construction procedure, the framework initializes a predefined set of base states, queries the LLM for $a_t \in \mathcal{V}$2, expands the state inventory, and then queries the LLM for $a_t \in \mathcal{V}$3 using that effect/state inventory (Shen et al., 30 Sep 2025). This makes the graph a structured interface between language-based decomposition and symbolic executability.

A special class of actions, called state preparation actions, is defined formally. An action $a_t \in \mathcal{V}$4 is a state preparation action if its node $a_t \in \mathcal{V}$5 has exactly one outgoing edge to an agent state node and has no incoming edges from other state nodes. Such actions prepare the agent for later actions without depending on prior state; the paper uses find as the canonical example (Shen et al., 30 Sep 2025).

3. Adaptive planning paradigm

SDA-PLANNER does not commit to a static full-plan execution policy. Its planning paradigm is explicitly adaptive: the system generates an initial plan using LLM reasoning, executes it step by step, monitors the environment, diagnoses failures when they occur, repairs only the affected region of the plan, and then continues execution from the corrected segment (Shen et al., 30 Sep 2025).

The paper describes this as a closed-loop dynamic revision process. The workflow consists of initial plan generation from the instruction, stepwise execution, and—upon failure—backtracking and diagnosis, determination of whether the issue is an environment mismatch or a deeper precondition violation, reconstruction of the affected subsequence, reversal of previously executed actions when necessary, and resumption under the adapted plan. It also introduces fake execution for irreversible actions so that repair does not create additional state conflicts (Shen et al., 30 Sep 2025).

A common misconception is that SDA-PLANNER is simply a local retry mechanism. The supplied workflow contradicts that interpretation. The framework does perform local repair, but the repair is constrained by the State-Dependency Graph and is preceded by explicit diagnosis of whether the failed action’s dependencies were in fact satisfied by the executed history. In that sense, adaptation is neither blind local retry nor full regeneration from scratch; it is localized reconstruction conditioned on symbolic state relations (Shen et al., 30 Sep 2025).

This makes SDA-PLANNER distinct from fully regenerating Global Planner baselines and from tree-based methods whose search space is prepared in advance. It is also distinct from error-agnostic replanning strategies that do not distinguish environment state errors from action precondition errors (Shen et al., 30 Sep 2025).

4. Error Backtrack and Diagnosis

The Error Backtrack and Diagnosis module determines what kind of failure has occurred and how much of the plan must be rebuilt. Suppose the plan is

$a_t \in \mathcal{V}$6

and an error occurs at time $a_t \in \mathcal{V}$7 for action-object pair $a_t \in \mathcal{V}$8. The module examines the dependent states of $a_t \in \mathcal{V}$9 one by one and checks whether each is satisfied by the executed history (Shen et al., 30 Sep 2025).

If all dependencies are satisfied, the problem is treated as an environment-state mismatch, and the planner can use local replan from the current time step. If some dependency is unsatisfied, the problem is classified as an action precondition error, and the system attempts to localize the minimal subsequence responsible for corrupting the required state (Shen et al., 30 Sep 2025).

The simplest case occurs when the unsatisfied state node has only one incoming edge and that edge comes from a state preparation action. Then the remedy is to insert the corresponding preparation action at $\mathcal{V}$0, with

$\mathcal{V}$1

No deeper subsequence reconstruction is required in that case (Shen et al., 30 Sep 2025).

For more involved failures, the method identifies an error source point $\mathcal{V}$2, defined as the most recent moment before the failure when the required state changed from satisfied to unsatisfied: $\mathcal{V}$3 where

$\mathcal{V}$4

Here $\mathcal{V}$5 is the violated state and $\mathcal{V}$6 is the required value (Shen et al., 30 Sep 2025).

Using $\mathcal{V}$7, the module computes a reconstruction window $\mathcal{V}$8: $\mathcal{V}$9 where $o_t$0 is the set of state preparation actions and $o_t$1 is the set of error items, including $o_t$2 and related items in $o_t$3 (Shen et al., 30 Sep 2025).

The examples in the paper illustrate the intended semantics. In one case, failure of $o_t$4 at $o_t$5 is traced back to $o_t$6 at $o_t$7, because the latter action altered the holding state; a prior $o_t$8 at $o_t$9 is then treated as the preparatory action, giving $(a_t,o_t)$0 and $(a_t,o_t)$1 (Shen et al., 30 Sep 2025).

5. Adaptive Action SubTree Generation

Once the repair interval is known, SDA-PLANNER invokes Adaptive Action SubTree Generation to reconstruct only the affected subsequence. The objective is to build a valid subtree of candidate actions such that every path corresponds to an executable repaired segment. Each tree node is a mid-level action $(a_t,o_t)$2 (Shen et al., 30 Sep 2025).

The procedure has three stages. First, the LLM analyzes the error causes in the original subsequence and proposes corrective actions. Candidate nodes are drawn from both the LLM-suggested corrections and the original subsequence. Second, the system builds a constrained search tree. Third, it performs breadth-first search over that tree and uses state constraints from $(a_t,o_t)$3 to find an executable repaired subsequence (Shen et al., 30 Sep 2025).

A notable structural device is the treatment of non-splittable subsequences. If a subsequence

$(a_t,o_t)$4

acts on the same item throughout and that item is not in the set of error items $(a_t,o_t)$5, then $(a_t,o_t)$6 are treated as non-selectable nodes and $(a_t,o_t)$7 is a special optional node. This prevents the repair search from fragmenting an action chain that is intended to exert uninterrupted influence on the same item (Shen et al., 30 Sep 2025).

For a node $(a_t,o_t)$8 not inside a constrained subsequence, the child set is defined as

$(a_t,o_t)$9

where $\mathcal{G}$0 is the candidate list from the LLM and the original subsequence, and $\mathcal{G}$1 is the set already used on the current path (Shen et al., 30 Sep 2025).

The notCovered predicate is defined as

$\mathcal{G}$2

where $\mathcal{G}$3 is the edge set of $\mathcal{G}$4. Operationally, this prevents the child from overriding the state effect established by the parent (Shen et al., 30 Sep 2025).

The root node is a special empty action whose state equals the state immediately before the repair window, namely the state of $\mathcal{G}$5. After a repaired subtree is selected, the planner reverses actions between $\mathcal{G}$6 and $\mathcal{G}$7 to restore the environment state, then re-executes the corrected plan from $\mathcal{G}$8. For irreversible actions, fake execution can be used to avoid introducing additional inconsistencies (Shen et al., 30 Sep 2025).

6. Empirical evaluation and position within embodied planning

The reported evaluation is conducted on ALFRED, with all relevant methods tested under LOTA-BENCH using consistent prompts, consistent low-level controllers, and a GPT-4o-mini backend. Experimental details include an Intel Xeon Gold 6148 CPU @ 2.40GHz, seed $\mathcal{G}$9, and temperature $a \in \mathcal{V}$0 for deterministic outputs. The paper evaluates three metrics: SR (Success Rate), GC (Goal Condition Success Rate), and No. EC (Number of Error Corrections) (Shen et al., 30 Sep 2025).

The compared baselines include the non-LLM methods HLSM and SayCan, and the LLM-based planners LLM Planner, Global Planner, and Tree Planner. The average results reported in the paper are:

• HLSM: SR 23.96, GC 34.99
• SayCan: SR 11.09, GC 23.53
• LLM Planner: SR 35.66, GC 46.06, No. EC 3.63
• Global Planner: SR 39.31, GC 46.97, No. EC 2.24
• Tree Planner: SR 36.51, GC 44.09
• SDA-PLANNER: SR 41.27, GC 50.92, No. EC 3.06 (Shen et al., 30 Sep 2025)

On the split-wise results, SDA-PLANNER is also reported as best on both Valid Seen and Valid Unseen, with Valid Seen at SR 38.22 and GC 47.10, and Valid Unseen at SR 44.32 and GC 54.73. The paper states that, relative to the strongest alternatives, SDA-PLANNER improves SR by about 2% and GC by about 4% (Shen et al., 30 Sep 2025).

The ablation discussion isolates two design choices. First, removing adaptation causes SR and GC to drop sharply, especially with weaker LLMs. Second, replacing hard search-tree reconstruction with soft prompt constraints also degrades performance, indicating that the search tree is not merely an implementation detail but a substantive executability constraint (Shen et al., 30 Sep 2025).

Within the broader literature on LLM-based planning, SDA-PLANNER occupies a hybrid position. Like AdaPlanner, it treats plan revision as essential under feedback rather than optional under execution drift (Sun et al., 2023). Its distinctive contribution is to make that revision state-dependency aware and error-aware, using a graph over action preconditions and effects to localize repair. A plausible implication is that the framework’s gains arise less from stronger decomposition alone than from the coupling of LLM semantic reasoning with explicit symbolic constraints during recovery (Shen et al., 30 Sep 2025).