Adaptive Planning Graph Overview

• Adaptive Planning Graphs are graph-structured frameworks that dynamically adapt their structure, annotations, or traversal policies in response to context, observations, or feedback.
• They are applied in diverse domains including autonomous driving, robot motion planning, decentralized multi-agent systems, and knowledge-graph question answering.
• Their adaptivity is achieved through mechanisms such as online graph updates, learned behavior parameters, dynamic edge weight adjustments, and reflection-driven replanning.

Adaptive Planning Graph denotes a family of graph-structured planning formalisms in which the graph itself, its annotations, or its traversal policy changes with context, observations, constraints, or feedback. In the cited literature, the term appears in autonomous driving, tool-using language-model agents, decentralized multi-agent systems, robot motion planning, assembly and disassembly, knowledge-graph question answering, tutoring, and adaptive path planning. Across these settings, graphs encode agents and lanes, subtasks and dependencies, steps/goals/long-term goals, parts and precedence constraints, prerequisite structures, or abstract states and actions; adaptivity is realized through learned behavior parameters, online graph updates, dynamic edge weights, reflection-driven backtracking, or replanning under mismatch (Vasudevan et al., 2024, Wu et al., 29 Oct 2025, Yang et al., 8 Feb 2025, Kraljusic et al., 1 Jul 2025, Shek et al., 4 Feb 2026, Jeong et al., 23 Feb 2026, Chen et al., 2024).

1. From classical plan graphs to broader adaptive graph formalisms

In Graphplan-style planning, the plan graph is a layered, bipartite structure alternating fact and action layers, with mutex relations marking incompatible facts or actions. STAN keeps this semantics but implements it with a spike representation, bit vectors, and a wave front so that the graph is not explicitly constructed beyond the fixpoint; the paper defines a fixpoint as a layer $FP$ such that $F_{FP} = F_{FP+1}$, $A_{FP} = A_{FP+1}$, and all mutexes are identical beyond $FP$ (Fox et al., 2011). Graph transformation planning generalizes the plan-graph idea to graph transformation systems: a relaxed abstraction applies all applicable rules in parallel, keeps deletions as labels deleted, reinterprets NACs, and extracts a relaxed plan length from label propagation over the abstract state sequence (Ziegert, 2014). Distributed Planning Through Graph Merging retains the leveled planning graph but makes it multi-agent: each agent builds a local Graphplan-style graph, incrementally merges actions that assist or threaten other agents, and coordinates extracted plans through CSP constraints (Pellier et al., 2018).

This historical lineage suggests that “Adaptive Planning Graph” is not a single standardized object. In more recent work, the same phrase denotes DAGs of subtask dependencies, agent–lane interaction graphs, hierarchical knowledge graphs, state–action dependency graphs, configuration-space graphs with adaptive motion primitives, or dynamically updated knowledge graphs that drive symbolic replanning (Wu et al., 29 Oct 2025, Vasudevan et al., 2024, Yang et al., 8 Feb 2025, Kraljusic et al., 1 Jul 2025, Shek et al., 4 Feb 2026).

2. Graph structures and state representations

In autonomous driving, the graph is an interaction-and-map structure. "Planning with Adaptive World Models for Autonomous Driving" defines an agent interaction graph $G=(V,E)$ whose nodes represent road users and map elements, and a lane graph $G_{\text{lane}}=(V_{\text{lane}},E_{\text{lane}})$ processed by a GCNN. BehaviorNet fuses agent histories with lane features through attention, yielding an “adaptive behavior graph” in which learned behavior parameters $\hat{\boldsymbol{\theta}}$ modulate the world model used by AdaptiveDriver (Vasudevan et al., 2024).

In LLM agent planning, a recurrent form is the dependency DAG. GAP defines $G=(V,E)$ as a directed acyclic graph in which each vertex is a sub-task $s_i$ and each edge $(v_i,v_j)$ denotes that $F_{FP} = F_{FP+1}$0 depends on the output of $F_{FP} = F_{FP+1}$1; topological levels then determine which tools can run in parallel (Wu et al., 29 Oct 2025). MMAPG also uses $F_{FP} = F_{FP+1}$2, but its nodes are reasoning steps of type $F_{FP} = F_{FP+1}$3, and new nodes can be attached to any earlier node, making graph growth explicitly non-linear and multi-path (Hu et al., 22 Aug 2025). PoG instead maintains a searched subgraph $F_{FP} = F_{FP+1}$4, a set of reasoning paths $F_{FP} = F_{FP+1}$5, and sub-objective status $F_{FP} = F_{FP+1}$6, so that adaptive breadth and reflection operate over a persistent KG-derived planning state (Chen et al., 2024).

A second recurrent form is the knowledge graph or hierarchical memory graph. DAMCS models each agent’s long-term memory as a goal-oriented hierarchical knowledge graph $F_{FP} = F_{FP+1}$7, with step nodes $F_{FP} = F_{FP+1}$8, goal nodes $F_{FP} = F_{FP+1}$9, and long-term-goal nodes $A_{FP} = A_{FP+1}$0, linked by temporal, goal-membership, goal-hierarchy, and goal-sequence edges (Yang et al., 8 Feb 2025). GraphMASAL plans over a dynamic knowledge graph $A_{FP} = A_{FP+1}$1 whose planning subgraph consists of concepts and prerequisite edges, while learner state is stored through mastery and misconception relations (Zeng et al., 14 Nov 2025). KGLAMP uses a knowledge graph $A_{FP} = A_{FP+1}$2 decomposed into $A_{FP} = A_{FP+1}$3, separating spatial or semantic relations, robot and object properties, and reachability (Shek et al., 4 Feb 2026).

In embodied and robotic settings, several papers define explicitly operational graphs. eGRAP represents electronic-device disassembly as a directed precedence graph $A_{FP} = A_{FP+1}$4 whose nodes are detected part instances and whose edges encode precedence or access constraints; the ready set is

$A_{FP} = A_{FP+1}$5

This ready set is the basis for topological task dispatch to two arms (Das et al., 21 Jan 2026). SDA-PLANNER defines a bipartite State-Dependency Graph with action nodes $A_{FP} = A_{FP+1}$6, state nodes $A_{FP} = A_{FP+1}$7, action $A_{FP} = A_{FP+1}$8 state edges for effects, and state $A_{FP} = A_{FP+1}$9 action edges for preconditions (Shen et al., 30 Sep 2025). PyCAALP builds a layered directed graph $FP$0 whose nodes are assembly states (cutsets) and whose edges are feasible operations weighted by engineering costs (Hartmann et al., 15 Dec 2025). Search-based robot motion planning with burs uses a lazily constructed configuration-space graph in which successor edges are generated online from local distance-to-obstacle information $FP$1, so local graph connectivity changes with clearance (Kraljusic et al., 1 Jul 2025).

3. Mechanisms of adaptivity

One mechanism is adaptive annotation of graph nodes or edges by learned or inferred latent state. In AdaptiveDriver, BehaviorNet does not predict future trajectories directly; it predicts cluster-dependent IDM controller parameters $FP$2, making the world model change across cities and logs (Vasudevan et al., 2024). GraphMASAL changes node costs through updated mastery values, because the cost function

$FP$3

is recomputed as learner state changes (Zeng et al., 14 Nov 2025). KGLAMP updates triples in $FP$4 after failures, regenerates problem PDDL from the repaired graph, and replans from the revised symbolic state (Shek et al., 4 Feb 2026).

A second mechanism is adaptive graph growth, pruning, or backtracking. PoG grows $FP$5 and $FP$6 iteratively, then uses reflection to decide whether additional entities should be added from earlier explored candidates $FP$7, effectively backtracking to prior KG regions (Chen et al., 2024). MMAPG adds nodes and edges on the fly according to LLM planning outputs, and a new node may use any previous nodes as parents, allowing the planner to bypass a flawed branch rather than extend it (Hu et al., 22 Aug 2025). Graph Counselor likewise treats graph exploration as a dynamic multi-agent process in which Planning, Thought, and Execution Agents revise graph operations, and the SR module injects reflective summaries that alter subsequent planning (Gao et al., 4 Jun 2025).

A third mechanism is adaptive geometry or cost in physical planning graphs. In the bur-based manipulator planner, the local successor set $FP$8 depends on clearance $FP$9; large $G=(V,E)$0 yields longer spines and coarser graph expansion, while $G=(V,E)$1 triggers fallback to fixed primitives (Kraljusic et al., 1 Jul 2025). In assistive-care path planning, the default graph $G=(V,E)$2 is transformed into a heated environment map $G=(V,E)$3, in which predicted human motion raises edge risk and changes the Dijkstra solution and the PRISM-validated path success probability (Hamilton et al., 2022). In adaptive informative path planning, a robot reconstructs a local graph $G=(V,E)$4 at every timestep from updated occupancy, GP utility, uncertainty, and semantic indicators, so the effective action graph changes with newly discovered obstacles and targets (Vashisth et al., 2024). PyCAALP performs a different kind of adaptivity: it prunes its layered directed graph using Single-Piece Flow, DoF-based collision checks, shortest-path preservation, and randomized edge removal, then re-optimizes on the reduced graph (Hartmann et al., 15 Dec 2025).

A fourth mechanism is adaptive scheduling rather than topology change. The planner-selection paper learns a GNN embedding $G=(V,E)$5 of a planning-task graph and uses a second-stage model

$G=(V,E)$6

to decide at halftime whether to keep the current planner or switch, conditioned on the observed fact that the first planner has not finished by $G=(V,E)$7 (Ma et al., 2018).

4. Planning and execution algorithms on adaptive graphs

Adaptive planning graphs support several distinct planning algorithms. In autonomous driving, AdaptiveDriver embeds the adaptive graph into model-predictive control:

$G=(V,E)$8

and implements optimization as trajectory sampling plus scoring rather than gradient-based solvers (Vasudevan et al., 2024). In GAP, the graph is executed level by level after a topological sort; all nodes in level $G=(V,E)$9 are mutually independent and are scheduled in a parallel batch $G_{\text{lane}}=(V_{\text{lane}},E_{\text{lane}})$0 (Wu et al., 29 Oct 2025). eGRAP uses the same topological principle in robotics: the Sequence Generator recomputes the ready set $G_{\text{lane}}=(V_{\text{lane}},E_{\text{lane}})$1, and the Scheduler dispatches non-interfering ready nodes to the tooling arm or manipulation arm, subject to precedence and workspace non-overlap (Das et al., 21 Jan 2026).

In decentralized and multi-agent planning, the graph acts as persistent memory or symbolic coordination substrate. DAMCS embeds each agent in a Dec-POMDP

$G_{\text{lane}}=(V_{\text{lane}},E_{\text{lane}})$2

and makes the policy effectively depend on observation, messages, short-term working memory, and hierarchical knowledge graph $G_{\text{lane}}=(V_{\text{lane}},E_{\text{lane}})$3 (Yang et al., 8 Feb 2025). KGLAMP uses multiple LLMs to turn $G_{\text{lane}}=(V_{\text{lane}},E_{\text{lane}})$4 into PDDL predicates and then uses Fast Downward for plan generation; if execution yields error $G_{\text{lane}}=(V_{\text{lane}},E_{\text{lane}})$5, the replanning loop evaluates candidate graph repairs $G_{\text{lane}}=(V_{\text{lane}},E_{\text{lane}})$6 and commits the repair maximizing $G_{\text{lane}}=(V_{\text{lane}},E_{\text{lane}})$7 (Shek et al., 4 Feb 2026).

For LM agents operating under hard feasibility constraints, TAPE converts multiple LM-generated plans into a graph and solves for a feasible path with an external solver. Its ILP path-selection objective is

$G_{\text{lane}}=(V_{\text{lane}},E_{\text{lane}})$8

with flow conservation, terminal-node, and budget constraints, after which constrained decoding forces execution of the chosen edge action and replanning is triggered whenever the realized abstract state mismatches the intended node (Jeong et al., 23 Feb 2026). In graph transformation planning, the corresponding algorithmic pattern is different: relaxed abstract transitions are applied in parallel to estimate the length of a relaxed plan, and that estimate guides concrete heuristic search (Ziegert, 2014). STAN’s wave front is another distinct pattern: once the fixpoint is reached, candidate goal sets are propagated between fixpoint and buffer rather than constructing sterile layers (Fox et al., 2011).

5. Representative applications and empirical evidence

Setting	Graph object	Adaptive signal
Autonomous driving (Vasudevan et al., 2024)	Agents + lane graph	Behavior clusters and $G_{\text{lane}}=(V_{\text{lane}},E_{\text{lane}})$9
Tool-use LLM agent (Wu et al., 29 Oct 2025)	Sub-task DAG	Topological levels and dependency-aware parallelization
Decentralized cooperative agents (Yang et al., 8 Feb 2025)	Hierarchical knowledge graph	Online consolidation and structured communication
Manipulator motion planning (Kraljusic et al., 1 Jul 2025)	Configuration-space search graph	Clearance-driven bur spines
Dual-arm disassembly (Das et al., 21 Jan 2026)	Part-precedence DAG	Online graph updates from perception and execution
Personalized tutoring (Zeng et al., 14 Nov 2025)	Dynamic knowledge graph	Updated mastery, sinks, and node costs
KG-guided multi-robot planning (Shek et al., 4 Feb 2026)	Relation/property/reachability KGs	Graph repair after planner or execution error
Multimodal QA (Hu et al., 22 Aug 2025)	Reasoning-step graph	Dynamic branching from any prior node
Assembly and production planning (Hartmann et al., 15 Dec 2025)	Layered weighted directed graph	Constraint-based pruning and $\hat{\boldsymbol{\theta}}$0 trade-offs
Embodied task planning (Shen et al., 30 Sep 2025)	State-dependency graph + action subtree	Error localization and local reconstruction
Constrained LM agents (Jeong et al., 23 Feb 2026)	Plan graph over abstract states	Solver-based path selection and mismatch replanning

The empirical record is heterogeneous but consistently favorable to adaptive formulations. In nuPlan closed-loop planning, AdaptiveDriver w/ Log-BehaviorNet reaches $\hat{\boldsymbol{\theta}}$1 and $\hat{\boldsymbol{\theta}}$2, versus $\hat{\boldsymbol{\theta}}$3 and $\hat{\boldsymbol{\theta}}$4 for PDM-C, with a closed-loop error reduction from $\hat{\boldsymbol{\theta}}$5 to $\hat{\boldsymbol{\theta}}$6, and the paper also reports improvement over prior work by $\hat{\boldsymbol{\theta}}$7 on Test-14 Hard R-CLS (Vasudevan et al., 2024). GAP-3B achieves a $\hat{\boldsymbol{\theta}}$8 average EM improvement over the best baseline on multi-hop datasets, while reducing turns, response length, and batch inference time; on HotpotQA, turns are 1.78 for GAP-3B versus 2.27 for AFM-RL-3B and 2.69 for Search-R1 (Wu et al., 29 Oct 2025).

In cooperative multi-agent planning, DAMCS reports that compared to single-agent scenarios, the two-agent scenario achieves the same goal with 63% fewer steps, and the six-agent scenario with 74% fewer steps; concretely, LLM Mem reaches $\hat{\boldsymbol{\theta}}$9 steps to diamond, 2 Agents Mem+Comm reaches $G=(V,E)$0, and 6 Agents Mem+Comm reaches $G=(V,E)$1 (Yang et al., 8 Feb 2025). In GraphMASAL, the MSMS planner obtains PathSim $G=(V,E)$2, Coverage $G=(V,E)$3, and Total Cost $G=(V,E)$4, while cognitive diagnosis reaches F1 $G=(V,E)$5 (Zeng et al., 14 Nov 2025). In KGLAMP, task completion improves by at least $G=(V,E)$6 over both LLM-only and PDDL-based variants, and under partial observability KGLAMP reaches TCR $G=(V,E)$7 versus $G=(V,E)$8 for LaMMA-P (Shek et al., 4 Feb 2026).

In motion and task planning for robots, the bur-based search planner finds solutions up to 60% faster and with 60% fewer expansions in higher-dimensional scenarios (Kraljusic et al., 1 Jul 2025). eGRAP reports Precision $G=(V,E)$9–$s_i$0, Recall $s_i$1–$s_i$2, mAP@0.5 $s_i$3–$s_i$4, mean localisation error $s_i$5–$s_i$6 px, and an overall completion rate of $s_i$7 HDD disassemblies ($s_i$8) (Das et al., 21 Jan 2026). In assistive-care path planning, success rate declines from approximately $s_i$9 at $(v_i,v_j)$0 to approximately $(v_i,v_j)$1 at $(v_i,v_j)$2, showing both the effectiveness and the fragility of edge-risk adaptation under increasing human unpredictability (Hamilton et al., 2022). In adaptive informative path planning, the dynamic-graph RL method is reported to enable more efficient target discovery than state-of-the-art learning and non-learning baselines (Vashisth et al., 2024).

In reasoning and agentic settings, MMAPG reaches F1 $(v_i,v_j)$3 on MultimodalQA and QA-Acc $(v_i,v_j)$4 on WebQA, while the ablation without graph-guided planning drops multi-hop F1 from $(v_i,v_j)$5 to $(v_i,v_j)$6 and EM from $(v_i,v_j)$7 to $(v_i,v_j)$8 (Hu et al., 22 Aug 2025). PoG improves GPT-4 performance from 67.6 to 75.0 on CWQ and from 82.6 to 87.3 on WebQSP, while also reducing LLM calls and time substantially relative to ToG (Chen et al., 2024). TAPE improves success rates by 21.0 percentage points on hard settings on average, and by 20.0 percentage points for weaker base models on average; on Sokoban it reports planning error $(v_i,v_j)$9, sampling error $F_{FP} = F_{FP+1}$00, and success rate $F_{FP} = F_{FP+1}$01, versus $F_{FP} = F_{FP+1}$02 for Plan-and-Act (Jeong et al., 23 Feb 2026).

6. Limitations, ambiguities, and open issues

A recurring ambiguity is that “adaptivity” is used in several non-equivalent senses. In some papers it means online topology change or graph repair; in others it means adaptive edge weights, adaptive node features, adaptive branching breadth, or adaptive scheduling. This suggests a family resemblance rather than a settled formal standard (Vasudevan et al., 2024, Kraljusic et al., 1 Jul 2025, Wu et al., 29 Oct 2025, Ma et al., 2018, Chen et al., 2024).

Domain-specific limitations are explicit. In autonomous driving, IDM only models longitudinal car-following with one lead vehicle, pedestrians and cyclists remain on constant velocity rollouts, and uncertainty in behavior prediction is not explicitly modeled; the paper also notes that nuPlan’s C3 performance is already high ($F_{FP} = F_{FP+1}$03) and may be becoming saturated (Vasudevan et al., 2024). GAP does not present formal complexity or optimality proofs, and its extensions to hierarchical graphs and dynamic graphs are described as potential extensions rather than implemented results (Wu et al., 29 Oct 2025). DAMCS notes challenges in memory quality, graph scale, noisy information, and partial observability (Yang et al., 8 Feb 2025). The bur-based manipulator planner assumes static environments, restricts spines to single-joint motions, and uses a heuristic that is not specialized for burs (Kraljusic et al., 1 Jul 2025).

Several papers identify modeling simplifications that limit graph expressiveness. eGRAP assumes a relatively simple dependency structure and notes that more complex devices with non-tree structures, shared fasteners, or flexible elements would require richer graph models such as AND/OR graphs or hyperedges (Das et al., 21 Jan 2026). SDA-PLANNER depends on the accuracy of LLM-derived $F_{FP} = F_{FP+1}$04 and $F_{FP} = F_{FP+1}$05, has limited state-variable coverage, and treats reverse execution and fake execution heuristically for irreversible actions (Shen et al., 30 Sep 2025). Assistive-care planning uses a simple human model, focuses mainly on path-level rather than mission-order replanning, and is evaluated only in simulation (Hamilton et al., 2022).

Finally, graph-guided LLM systems inherit substantial computational and modeling burdens. KGLAMP is computationally heavy because it requires multiple LLM calls and replanning iterations, and it acknowledges that LLM-generated PDDL can still be invalid (Shek et al., 4 Feb 2026). TAPE’s graph quality depends on LM-generated candidate plans, and performance can degrade when the number of sampled plans becomes too large (Jeong et al., 23 Feb 2026). PoG identifies LLM self-confidence and efficiency as open problems, especially for complex questions and non-standardized queries (Chen et al., 2024). PyCAALP makes the trade-off explicit: complexity-reduction techniques may sacrifice optimality even while significantly reducing MIP computational time (Hartmann et al., 15 Dec 2025). Graph transformation planning via abstraction provides a strong heuristic but the abstraction itself is computationally expensive and the heuristic is not admissible (Ziegert, 2014).

Taken together, these works indicate that Adaptive Planning Graphs are most mature as a design pattern: a graph-structured state, dependency, or memory substrate is maintained; adaptation is triggered by observations, uncertainty, or execution feedback; and planning then proceeds by search, optimization, scheduling, or reflection over that evolving graph.