---
title: 'SDA-PLANNER: State-Dependency Aware Adaptive Planner'
url: https://www.emergentmind.com/topics/sda-planner
type: topic
---

# SDA-PLANNER: State-Dependency Aware Adaptive Planner

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 [2509.26375].

## 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 [2509.26375].

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 [2509.26375].

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 [2305.16653].

## 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{A}_i=(a_i,o_i)\) [2509.26375].

The graph itself is a **directed bipartite graph** with action nodes \(N_a\) and state nodes \(\mathcal{N}_s\). A directed edge \(n_a \to n_s\) means that action \(a\) modifies state \(s\), and the edge is annotated with the resulting value \(v\). A directed edge \(n_s \to n_a\) means that action \(a\) requires state \(s\) to have value \(v\) before execution. In operational terms, \(\mathcal{G}\) 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 [2509.26375].

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 \(\mathcal{S}_{\text{eff}[a]\), expands the state inventory, and then queries the LLM for \(\mathcal{S}_{\text{dep}[a]\) using that effect/state inventory [2509.26375]. 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\) is a state preparation action if its node \(n_a\) 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 [2509.26375].

## 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 [2509.26375].

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 [2509.26375].

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 [2509.26375].

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** [2509.26375].

## 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
\[
\mathcal{P}=\{(a_1, o_1), (a_2, o_2), ...\}
\]
and an error occurs at time \(t_{\text{error}\) for action-object pair \((a_{\text{error}, o_{\text{error})\). The module examines the dependent states of \((a_{\text{error}, o_{\text{error})\) one by one and checks whether each is satisfied by the executed history [2509.26375].

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 [2509.26375].

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 \(t_{\text{error}\), with
\[
t_{\text{start} = t_{\text{error} = t_{\text{end}.
\]
No deeper subsequence reconstruction is required in that case [2509.26375].

For more involved failures, the method identifies an **error source point** \(t_{\text{source}\), defined as the most recent moment before the failure when the required state changed from satisfied to unsatisfied:
\[
t_{\text{source} = \left\{ \begin{aligned} & \operatorname*{max} \{t | t \in \Lambda\}, &\quad \Lambda \neq \emptyset \\
& 1, & \quad \Lambda = \emptyset , \end{aligned} \right.
\]
where
\[
\Lambda = \{t | t< t_\text{error} \land (s_\text{error}[t-1] = v_\text{need}) \land (s_\text{error}[t] \neq v_\text{need})\}.
\]
Here \(s_{\text{error}\) is the violated state and \(v_{\text{need}\) is the required value [2509.26375].

Using \(t_{\text{source}\), the module computes a reconstruction window \([t_{\text{start}, t_{\text{end}]\):
\[
\begin{aligned}
t_{\text{start} &= \min\{ t \mid \{ a_i \mid \mathcal{A}_i = (a_i, o_i), \forall i \in [t, t_{\text{source}) \} \subseteq \mathcal{A}_{\text{prep} \} \\
t_{\text{end} &= \max\{ t \mid \{ o_i \mid A_i = (a_i, o_i), \forall i \in (t_{\text{error}, t] \} \subseteq \mathcal{O}\},
\end{aligned}
\]
where \(\mathcal{A}_{\text{prep}\) is the set of state preparation actions and \(\mathcal{O}\) is the set of error items, including \(o_{\text{error}\) and related items in \(s_{\text{error}\) [2509.26375].

The examples in the paper illustrate the intended semantics. In one case, failure of \((\text{pick up}, \text{tomato})\) at \(t=7\) is traced back to \((\text{pick up}, \text{pan})\) at \(t=3\), because the latter action altered the holding state; a prior \((\text{find}, \text{pan})\) at \(t=2\) is then treated as the preparatory action, giving \(t_{\text{start}=2\) and \(t_{\text{end}=8\) [2509.26375].

## 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 \(\mathcal{A}=(a,o)\) [2509.26375].

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 \(\mathcal{G}\) to find an executable repaired subsequence [2509.26375].

A notable structural device is the treatment of **non-splittable** subsequences. If a subsequence
\[
\mathcal{P}'=\{\mathcal{A}_i,\cdots,\mathcal{A}_j\}
\]
acts on the same item throughout and that item is not in the set of error items \(\mathcal{O}\), then \(\mathcal{A}_{i+1}, \ldots, \mathcal{A}_j\) are treated as **non-selectable nodes** and \(\mathcal{A}_i\) 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 [2509.26375].

For a node \(\mathcal{A}_t\) not inside a constrained subsequence, the child set is defined as
\[
N = \{\mathcal{A}_j \in \{\mathcal{V}_r - \mathcal{V}_{\text{used}\} \mid \text{satisfied}(\mathcal{A}_j, \mathcal{G}) \land \text{change}(\mathcal{A}_j, \mathcal{G}) \land \text{notCovered}(\mathcal{A}_t, \mathcal{A}_j)\},
\]
where \(\mathcal{V}_r\) is the candidate list from the LLM and the original subsequence, and \(\mathcal{V}_{used}\) is the set already used on the current path [2509.26375].

The **notCovered** predicate is defined as
\[
\text{notCovered}(\mathcal{A}_t, \mathcal{A}_j) = \left\{ \begin{aligned}
& \text{True}, &\exists s, (\mathcal{A}_t, s)\in \mathcal{E} \land (\mathcal{A}_j, s) \notin \mathcal{E} \\
& \text{False}, & otherwise, \end{aligned} \right.
\]
where \(\mathcal{E}\) is the edge set of \(\mathcal{G}\). Operationally, this prevents the child from overriding the state effect established by the parent [2509.26375].

The root node is a special empty action whose state equals the state immediately before the repair window, namely the state of \(\mathcal{A}_{\text{start}-1}\). After a repaired subtree is selected, the planner reverses actions between \(t_{\text{start}\) and \(t_{\text{error}\) to restore the environment state, then re-executes the corrected plan from \(t_{\text{start}\). For irreversible actions, **fake execution** can be used to avoid introducing additional inconsistencies [2509.26375].

## 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 \(=1\), and temperature \(=0\) for deterministic outputs. The paper evaluates three metrics: **SR (Success Rate)**, **GC (Goal Condition Success Rate)**, and **No. EC (Number of Error Corrections)** [2509.26375].

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 [2509.26375]

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%** [2509.26375].

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 [2509.26375].

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 [2305.16653]. 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 [2509.26375].

Source: https://www.emergentmind.com/topics/sda-planner