Action Dependency Graph Overview

• Action Dependency Graphs are graph-structured representations that encode dependencies among actions, events, or decisions, clarifying execution order and coordination.
• They are applied in MAPF, LLM agent planning, and MARL to optimize scheduling, tool-call ordering, and multi-agent policy coordination across various domains.
• Recent studies focus on sparsifying redundant dependencies and employing semi-autoregressive techniques to improve ADG generation, execution, and parsing efficiency.

Searching arXiv for recent and canonical papers on “Action Dependency Graph” and closely related formulations to ground the article in the cited literature. An Action Dependency Graph (ADG) is a directed dependency structure in which nodes denote actions, events, tool calls, route-execution events, or action choices, and edges denote some form of dependency that constrains how those nodes may be interpreted, generated, or executed. In the literature represented here, the term does not denote a single universal formalism. Instead, it appears as an execution schedule derived from Multi-Agent Path Finding (MAPF), a graph of tool-use actions and input-output dependencies in LLM agents, a directed acyclic conditioning structure for multi-agent policies, and a transferable abstraction for partially ordered graph generation and parsing (Berndt et al., 2020, Dunkel, 2024, Ding et al., 1 Jun 2025, Zhang et al., 2 Jul 2026, Ma et al., 2023).

1. Conceptual scope and domain-specific meanings

The common core of an ADG is a dependency relation among action-like objects. What varies across domains is the semantics of the nodes and edges. In MAPF execution, nodes are movement events of Automated Guided Vehicles (AGVs), and an edge means one event cannot become in-progress or completed until another is completed (Berndt et al., 2020). In Atomic Task Graph (ATG), nodes are concrete tool calls $v_j=(i_j,f_j,o_j)$, and an edge $e_{jk}: v_j \rightarrow v_k$ means that output $o_j$ is used as part of input $i_k$ (Zhang et al., 2 Jul 2026). In cooperative MARL, an ADG specifies which earlier agents’ actions each agent conditions on, yielding a factorization $$\pi(a|s)=\prod_{i=1}^n \pi_i(a_i \mid s, a_{N_d(i)})$$ (Ding et al., 1 Jun 2025). In other work, the graph is implicit rather than explicit: ACE uses a sequential dependency chain over agents’ actions with forward dependence at inference and backward dependence in Bellman backup (Li et al., 2022).

Domain	Node semantics	Edge semantics
MAPF / AGV execution	Route-execution event $v_i^k$	Precedence constraint between events (Berndt et al., 2020)
LLM agent planning	Tool call $v_j=(i_j,f_j,o_j)$	Output of one call used in another’s input (Zhang et al., 2 Jul 2026)
Cooperative MARL	Agent action or agent–action choice	Conditioning or coordination dependency (Ding et al., 1 Jun 2025, Gupta et al., 19 Feb 2026)

Earlier game-oriented work also used dependency graphs for prerequisite structure. In “Developing Parallel Dependency Graph in Improving Game Balancing,” the dependency graph models prerequisite relationships among assets and thereby the sequence of asset possession; this maps naturally to action unlocking and action order in games (Tee, 2013). In “Functional Dependence in Strategic Games,” the graph is instead a graph of payoff locality: a player’s utility depends only on the strategies of neighbors in an undirected graph $\Gamma=(V,E)$, and the paper studies what equilibrium-level functional dependencies $A \rhd B$ follow from that structure (Harjes et al., 2013). This suggests that “dependency” in ADG-adjacent literature ranges from temporal precedence to data flow, payoff locality, kinematic influence, and equilibrium determination.

2. Formal structures, partial orders, and graph factorization

Several ADG formalisms are explicitly DAG-oriented. ATG represents a plan as an explicit DAG $G=(V,E)$, recursively refines non-atomic nodes into subgraphs, and maintains a sequence of DAGs whose evolution can be traced (Zhang et al., 2 Jul 2026). The semi-autoregressive graph generation model “SAGER” is also DAG-oriented for generation: it converts a dependency graph into topological hierarchies, with $e_{jk}: v_j \rightarrow v_k$0 and, for $e_{jk}: v_j \rightarrow v_k$1, $e_{jk}: v_j \rightarrow v_k$2, where $e_{jk}: v_j \rightarrow v_k$3 contains nodes introduced at topological hierarchy $e_{jk}: v_j \rightarrow v_k$4 and $e_{jk}: v_j \rightarrow v_k$5 contains incoming labeled edges from previously generated nodes (Ma et al., 2023). Its graph joint probability is factorized as

$e_{jk}: v_j \rightarrow v_k$6

with groups generated autoregressively across hierarchies and elements generated in parallel within a hierarchy (Ma et al., 2023).

This hierarchy-based formulation is directly relevant to ADGs when actions are only partially ordered. The paper defines

$e_{jk}: v_j \rightarrow v_k$7

so later-layer nodes depend only on earlier-layer nodes (Ma et al., 2023). The authors’ critique is that fully autoregressive graph generation imposes arbitrary total orders on siblings, while fully non-autoregressive generation ignores genuine output dependencies. Their semi-autoregressive compromise is motivated by a “mixture of independent and interdependent components” (Ma et al., 2023). A plausible implication is that ADGs are most naturally modeled as partial orders with structured conditional independence, rather than as either flat independent edge sets or fully linearized sequences.

Not all action-dependency structures are acyclic. Enhanced dependency graph parsing work explicitly handles reentrancy and cycles, and sequence-labeling encodings are extended from trees to dependency graphs $e_{jk}: v_j \rightarrow v_k$8 with one label per token (Ezquerro et al., 2024). Conversely, many action-planning and execution systems remain DAG-oriented even when target structures may contain a few cycles. SAGER deletes back edges during generation and later adds them back by rules before evaluation (Ma et al., 2023). ATG requires DAG execution in topological order (Zhang et al., 2 Jul 2026). These differences reflect a substantive design choice rather than a terminological inconsistency.

3. Execution scheduling in MAPF and robotic coordination

The most explicit and classical ADG formalization in this set appears in MAPF execution. “A Feedback Scheme to Reorder a Multi-Agent Execution Schedule by Persistently Optimizing a Switchable Action Dependency Graph” defines an ADG as a directed graph

$e_{jk}: v_j \rightarrow v_k$9

where each vertex

$o_j$0

denotes the $o_j$1 event of the $o_j$2 AGV moving from $o_j$3 to $o_j$4, with $o_j$5 (Berndt et al., 2020). Type 1 edges encode within-agent sequencing, and Type 2 edges encode inter-agent ordering at shared roadmap vertices or conflicting regions. If execution adheres to the dependencies of an acyclic ADG, the paper proves collision-free and deadlock-free plan execution under a finite number of delays of finite duration (Berndt et al., 2020).

That paper’s central contribution is the Switchable Action Dependency Graph (SADG), which allows some Type 2 dependencies to be reversed online while preserving acyclicity. A forward dependency $o_j$6 enforces $o_j$7; its reverse dependency enforces $o_j$8 (Berndt et al., 2020). The optimization objective is

$o_j$9

with binary variables selecting forward or reverse dependencies and temporal constraints enforcing Type 1 and Type 2 relations (Berndt et al., 2020). The paper proves recursive feasibility: if the initial ADG is acyclic, consecutive MILP solutions maintain acyclicity for all $i_k$0 (Berndt et al., 2020).

A later MAPF paper simplifies the ADG framework itself. “Streamlining the Action Dependency Graph Framework: Two Key Enhancements” proves that wait actions are generally redundant and can be removed without altering the action precedence order, and introduces Sparse Candidate Partitioning (SCP) to construct fewer Type 2 dependencies (Dunkel, 2024). The original exhaustive construction is quadratic in the worst case, $i_k$1; SCP reduces construction to $i_k$2 and yields at most one Type 2 dependency per action (Dunkel, 2024). The paper’s argument is graph-theoretic: a dependency is redundant if the target remains reachable after removing the direct edge, and many wait-action and cross-agent dependencies are transitively implied (Dunkel, 2024). Taken together, these MAPF results define ADGs as executable partial orders over route segments, with acyclicity functioning as a deadlock criterion and sparsification functioning as an execution- and construction-efficiency device.

4. Action-dependent policies and coordination in multi-agent reinforcement learning

In MARL, ADGs become policy-side conditioning structures. “Action Dependency Graphs for Globally Optimal Coordinated Reinforcement Learning” studies cooperative Markov games $i_k$3 under a coordination graph $i_k$4, where

$i_k$5

for pairwise interactions (Ding et al., 1 Jun 2025). The ADG is a directed acyclic graph $i_k$6 such that agent $i_k$7’s policy depends on the actions of agents in

$i_k$8

and the joint policy factorizes as

$i_k$9

The fully auto-regressive policy is the dense special case $$\pi(a|s)=\prod_{i=1}^n \pi_i(a_i \mid s, a_{N_d(i)})$$0 (Ding et al., 1 Jun 2025).

The paper’s main theorem gives a sufficient condition for global optimality: if a $$\pi(a|s)=\prod_{i=1}^n \pi_i(a_i \mid s, a_{N_d(i)})$$1-locally optimal policy satisfies

$$\pi(a|s)=\prod_{i=1}^n \pi_i(a_i \mid s, a_{N_d(i)})$$2

then $$\pi(a|s)=\prod_{i=1}^n \pi_i(a_i \mid s, a_{N_d(i)})$$3 (Ding et al., 1 Jun 2025). This is the theoretical basis for sparse ADGs: full dependence on all preceding agents is unnecessary when the coordination graph is sparse. The same paper proposes a tabular action-dependent multi-agent policy iteration algorithm and proves finite convergence to a globally optimal policy under this condition (Ding et al., 1 Jun 2025).

Related work uses different but compatible graph intuitions. “Action-Graph Policies” constructs a global action-dependency graph

$$\pi(a|s)=\prod_{i=1}^n \pi_i(a_i \mid s, a_{N_d(i)})$$4

whose nodes are agent–action pairs rather than agents, and computes coordination contexts by attention-based message passing over these nodes (Gupta et al., 19 Feb 2026). The paper proves $$\pi(a|s)=\prod_{i=1}^n \pi_i(a_i \mid s, a_{N_d(i)})$$5, so Action-Graph Policies are strictly more expressive than fully independent policies (Gupta et al., 19 Feb 2026). By contrast, ACE does not learn an explicit sparse graph, but it embodies “bidirectional action-dependency”: forward dependence during action selection and backward dependence during learning targets via sequentially expanded states $$\pi(a|s)=\prod_{i=1}^n \pi_i(a_i \mid s, a_{N_d(i)})$$6 (Li et al., 2022). These papers collectively show that an ADG in MARL may be explicit and sparse, soft and attention-based, or implicit and sequential. The shared purpose is to encode compatibility among actions beyond independent execution.

5. Planning, tool use, and runtime execution graphs in LLM agents

In LLM agents, the ADG idea becomes an explicit graph of executable tool-use actions. ATG defines the plan as a DAG $$\pi(a|s)=\prod_{i=1}^n \pi_i(a_i \mid s, a_{N_d(i)})$$7 in which each node $$\pi(a|s)=\prod_{i=1}^n \pi_i(a_i \mid s, a_{N_d(i)})$$8 is a tool invocation and each edge $$\pi(a|s)=\prod_{i=1}^n \pi_i(a_i \mid s, a_{N_d(i)})$$9 indicates that $v_i^k$0 is used as part of $v_i^k$1 (Zhang et al., 2 Jul 2026). Planning proceeds by interface-preserving recursive graph compilation: a non-atomic node is replaced by a subgraph $v_i^k$2, external input and output contracts are preserved, and refinement continues until every node is a directly executable atomic tool-use unit (Zhang et al., 2 Jul 2026). Execution follows topological order; a node becomes executable when all predecessor nodes have finished and required inputs have been resolved; branches with no unresolved dependency conflicts may execute in parallel (Zhang et al., 2 Jul 2026).

The paper emphasizes two operational consequences of explicit dependencies. First, validated intermediate results become reusable because dependencies are not left implicit in textual trajectories (Zhang et al., 2 Jul 2026). Second, failures can be localized using graph evolution history, so repair may be restricted to the affected region while validated regions remain unchanged (Zhang et al., 2 Jul 2026). This is a data-dependency interpretation of ADGs rather than a pure precedence interpretation, although topological execution induces precedence as a consequence.

“Tool-Call Dependency Structure is Linearly Decodable in LLM Agent Residual Streams” studies the same kind of structure as a runtime action dependency graph rather than a control framework (Sun et al., 25 May 2026). It defines a tool-call dependency DAG over executed trajectories, with a direct edge $v_i^k$3 when call $v_i^k$4’s output supplies an argument of call $v_i^k$5, operationalized in the main experiments by substring-based oracle rules and also replicated with an independent typed-value oracle (Sun et al., 25 May 2026). On $v_i^k$6-bench retail, a low-capacity linear probe on Qwen3-32B residual streams achieves AUROC $v_i^k$7 for direct dependency decoding and $v_i^k$8 for transitive-only multi-hop ancestry, above positional, surface-form, and random-label controls (Sun et al., 25 May 2026). The paper’s own caveat is that these claims concern representation, not behavioral control. Even so, it establishes that runtime tool-call dependency topology is not only an external execution artifact but also linearly decodable from internal model states (Sun et al., 25 May 2026).

6. Parsing, perception, and adjacent dependency-graph formulations

Several adjacent literatures treat ADGs as transferable abstractions rather than as the primary name of the object. “A Semi-Autoregressive Graph Generative Model for Dependency Graph Parsing” is a linguistic parser, but its formulation maps directly to action graphs: nodes may be actions or subgoals, edges may encode prerequisite, causal enablement, control dependency, or resource dependency, and topological hierarchies define stage-wise frontier expansion (Ma et al., 2023). The model gains a trade-off between non-autoregression and autoregression and reports about $v_i^k$9 average promotion at graph-level accuracy in the abstract, with especially strong improvements on graph-level matching score across Enhanced Universal Dependencies (Ma et al., 2023). This suggests that ADGs benefit from stage-wise generation when sibling actions are orderless or parallelizable.

Sequence-labeling work on dependency graph parsing provides a different lesson. By extending tree encodings to graphs with reentrancy and cycles, it defines unbounded positional and bracketing encodings and bounded $v_j=(i_j,f_j,o_j)$0-bit and $v_j=(i_j,f_j,o_j)$1-bit encodings that cast graph parsing as one-label-per-token tagging (Ezquerro et al., 2024). The paper reports that sequence-labeling graph parsers achieve high efficiency with accuracies close to the state of the art, and that $v_j=(i_j,f_j,o_j)$2-bit bounded encodings are often a strong practical compromise on sparse graph settings such as Enhanced UD (Ezquerro et al., 2024). For ADGs that are token-anchored or linearly ordered, this provides a concrete linearization perspective.

Action-recognition papers extend the dependency idea to spatio-temporal body dynamics. DD-GCN constructs a directed diffusion graph in which $v_j=(i_j,f_j,o_j)$3 means $v_j=(i_j,f_j,o_j)$4 moves around $v_j=(i_j,f_j,o_j)$5, thereby modeling physical dependency among joints rather than mere anatomical adjacency (Li et al., 2023). STC-Net adds adaptive spatio-temporal curves and dilated graph kernels so that a joint at time $v_j=(i_j,f_j,o_j)$6 may be most semantically related to a different joint at time $v_j=(i_j,f_j,o_j)$7 (Lee et al., 2022). These are not action dependency graphs in the planning or scheduling sense. However, they show that “dependency” can also denote action formation through kinematic and synchronized spatio-temporal relations.

7. Recurring design issues, misconceptions, and limitations

A recurrent misconception is that an ADG is always a DAG of temporal precedence constraints. The literature is more heterogeneous. Many execution and planning systems are DAG-based, but some parsing formalisms allow cycles, and some strategic-game formulations use undirected graphs of payoff dependence rather than directed execution graphs [(Berndt et al., 2020); (Zhang et al., 2 Jul 2026); (Ezquerro et al., 2024); (Harjes et al., 2013)]. Another misconception is that edges always mean “must happen before.” In ATG they mean data dependency; in MARL they mean conditioning structure; in DD-GCN they mean kinematic influence; in game theory they mean permitted local payoff dependence [(Zhang et al., 2 Jul 2026); (Ding et al., 1 Jun 2025); (Li et al., 2023); (Harjes et al., 2013)].

A second recurring issue is density. Several papers explicitly argue against dense or monolithic dependence structures. SAGER criticizes fully autoregressive graph generation for imposing arbitrary sibling order and fully non-autoregressive generation for ignoring explicit output dependencies (Ma et al., 2023). Sparse ADG theory in MARL shows that dense auto-regression is often unnecessary when the coordination graph is sparse (Ding et al., 1 Jun 2025). MAPF work shows that many ADG edges are transitively redundant and that wait actions may be removed (Dunkel, 2024). This suggests that an ADG is most useful when it isolates load-bearing dependencies rather than merely recording all conceivable relations.

A third issue is node ontology. Some frameworks assume nodes are already given and aligned to source words, as in dependency parsing (Ma et al., 2023, Ezquerro et al., 2024). Others define nodes as executable tool calls with explicit interfaces (Zhang et al., 2 Jul 2026). MAPF ADGs assume fixed plans and route segments (Berndt et al., 2020, Dunkel, 2024). In action domains where actions must first be extracted, segmented, or proposed, graph generation becomes strictly harder. That limitation is stated directly in the transfer discussion of SAGER and indirectly in ATG’s assumption that planning can refine toward atomic tool-use nodes (Ma et al., 2023, Zhang et al., 2 Jul 2026).

Across these literatures, the most stable encyclopedic characterization is therefore narrow but robust: an Action Dependency Graph is a graph-structured representation that externalizes dependencies among actions or action-like units so that order, conditioning, reuse, or coordination can be computed from the graph rather than inferred implicitly from a flat sequence. The precise semantics of “action,” “dependency,” and even “graph” remain domain-specific, but the central methodological motive is consistent: to expose structure that would otherwise remain implicit in trajectories, plans, schedules, or joint policies.