Agent Dependency Graphs: Structures & Applications

Updated 5 July 2026

Agent Dependency Graphs are formal graph representations that explicitly encode dependencies in agent systems, clarifying task execution and enabling parallel scheduling.
They are applied in diverse contexts—from planning and runtime tracing to static analysis and multi-agent coordination—through tailored node semantics and dependency rules.
These graphs facilitate efficient decomposition, verification, and error attribution, significantly improving performance metrics in planning and reinforcement learning scenarios.

Agent Dependency Graph denotes a family of graph formalisms that make dependencies explicit in agentic systems. In current literature, the term covers several related but non-identical objects: dependency DAGs over subtasks for planning and parallel tool use, concept graphs for auto-formalization, causal or information-flow graphs for post-hoc failure tracing, typed dependency graphs for static analysis of agent programs, supply-chain graphs for skills and services, and action-dependency graphs for coordinated multi-agent reinforcement learning. What these formulations share is the use of graph structure to externalize relations that are otherwise implicit in text traces, control flow, or learned policies, thereby enabling decomposition, scheduling, attribution, verification, retrieval, or optimization (Wu et al., 29 Oct 2025, Wang et al., 6 Oct 2025, Zhao, 22 Jun 2026, Wang et al., 2 Jul 2026).

1. Formal scope and graph semantics

The most common formulation is a directed acyclic graph. In GAP, the graph is $G=(V,E)$ , where each node $v_i$ is an atomic sub-task $s_i$ , and an edge $(v_i\to v_j)$ means that $s_j$ depends on the output of $s_i$ ; absence of an edge between two nodes implies independence and possible parallel execution (Wu et al., 29 Oct 2025). Atomic Task Graph uses the same DAG intuition, but each node is a triple $a_i=(i_i,f_i,o_i)$ containing a tool, its input, and its output, and each edge means that the output of one atomic subtask is used as input by another (Zhang et al., 2 Jul 2026).

Other papers retain acyclicity but change the node semantics. Aria defines an Agent Dependency Graph $G=(V,E)$ over mathematical concept nodes; a node may represent an intermediate lemma, a definition or structure, or a classifier or instance, and an edge $(u\to v)$ indicates that concept $u$ depends directly on concept $v_i$ 0 (Wang et al., 6 Oct 2025). This inversion of edge direction relative to GAP is important: the literature does not standardize whether edges point from prerequisite to dependent or from dependent to prerequisite.

A broader class of representations departs from plain DAGs. GRADE models one LLM-agent run as a two-layer directed, typed, temporal multigraph

$v_i$ 1

with execution-order edges, dependency-relation edges, node types $v_i$ 2, and an observability grade $v_i$ 3 over dependency edges distinguishing $v_i$ 4, $v_i$ 5, and $v_i$ 6 (Zhao, 22 Jun 2026). AgentFlow makes the representation still more explicit by defining an ADG for a program $v_i$ 7 as a triple

$v_i$ 8

combining an undirected Agent Component Dependency Graph, a directed Agent Control Flow Graph, and a directed Agent Data Flow Graph over typed nodes for agents, prompts, models, capabilities, states, and policies (Wang et al., 2 Jul 2026).

Setting	Node and edge interpretation	Example papers
Planning DAG	Subtasks or atomic tool calls; edges encode execution prerequisites	(Wu et al., 29 Oct 2025, Zhang et al., 2 Jul 2026, Dong et al., 2024)
Concept DAG	Mathematical concepts; edges encode formalization prerequisites	(Wang et al., 6 Oct 2025)
Runtime causal / information graph	Actions or information items; edges encode causal influence or citation/use	(Wang, 16 Mar 2026, Zhang et al., 12 Oct 2025)
Typed execution/dependency multigraph	Step nodes with execution and dependency layers	(Zhao, 22 Jun 2026)
Static program ADG	Program entities with component, control, and data edges	(Wang et al., 2 Jul 2026)
Skill / supply-chain graph	Skills, packages, services with typed dependency channels	(Jia et al., 1 Jul 2026, Liu et al., 7 Apr 2026)
MARL dependency graph	Agents or actions; edges encode conditioning structure in policy	(Ding et al., 1 Jun 2025, Gupta et al., 19 Feb 2026, Jia et al., 13 Mar 2025)

This variety suggests that “Agent Dependency Graph” functions less as a single canonical data structure than as a graph-centered design pattern for making agent dependencies operationally available.

2. Planning, decomposition, and parallel execution

In planning-oriented systems, the graph is produced before or during execution and then used to schedule work. GAP prompts a LLM to generate structured “<plan> ... </plan>” traces, reconstructs a DAG from subtask descriptions and dependency identifiers, and computes topological layers

$v_i$ 9

All nodes in the same layer form a parallel batch, and the decision rule

$s_i$ 0

formalizes independence (Wu et al., 29 Oct 2025). Trained with approximately 7,000 planning trajectories and then RL via DAPO, GAP-3B achieves 42.5% EM on HotpotQA versus 41.1% for the best sequential RL baseline, reduces interaction turns from 2.27 to 1.78 on HotpotQA and from 3.05 to 2.03 on 2WikiMultiHopQA, lowers wall-clock inference time from 248 s to 168 s on HotpotQA and from 262 s to 206 s on 2Wiki, and drops generated tokens from 554 to 416 on HotpotQA (Wu et al., 29 Oct 2025).

Atomic Task Graph generalizes the same dependency-aware scheduling principle to recursive graph evolution. Planning starts from a coarse node, repeatedly replaces non-atomic nodes with finer DAGs via $s_i$ 1, and preserves the parent node’s external interface while refining its interior (Zhang et al., 2 Jul 2026). Execution proceeds by topological scheduling over ready nodes

$s_i$ 2

and all ready nodes may be dispatched in parallel because they form an antichain in a DAG (Zhang et al., 2 Jul 2026). When a node fails, ATG localizes the fault through graph evolution history, extracts the descendant subgraph of the lowest-common ancestor, repairs only that region, and leaves validated regions unchanged; on ALFWorld, WebShop, and ScienceWorld, the paper reports reduced average execution depth by $s_i$ 3, a wall-clock step reduction from 31 to 18 on ALFWorld, and success-rate gains of more than 30 percentage points through localized repair (Zhang et al., 2 Jul 2026).

Aria uses the graph for conjecture-level formalization in Lean rather than tool orchestration. Its Graph-of-Thought process alternates retrieval from Mathlib with recursive decomposition of ungrounded concepts, then synthesizes formal code by post-order traversal of the dependency graph, invoking a compiler-in-the-loop reflection loop for up to a small number $s_i$ 4 of rounds (Wang et al., 6 Oct 2025). AriaScorer then performs term-level retrieval, subtask decomposition, and fuzzy-integral aggregation to verify semantic grounding. On ProofNet it reaches 91.6% compilation success and 68.5% final accuracy; on FATE-X it reaches 44.0% final accuracy versus 24.0% for the best baseline; on a dataset of homological conjectures it reaches 42.9% final accuracy while all other models score 0% (Wang et al., 6 Oct 2025).

VillagerAgent applies DAG scheduling to embodied multi-agent coordination in Minecraft. Nodes are subtasks $s_i$ 5, edges mean one subtask must finish before another may start, and the ready set is

$s_i$ 6

The Agent Controller assigns ready subtasks to free agents, who execute in parallel while all coordination is mediated through the shared graph and state manager (Dong et al., 2024). On VillagerBench, VillagerAgent cuts hallucination-driven failures to 18.2% versus 44.4% for AgentVerse in Farm-to-Table Cooking; with GPT-4 it reaches completion up to 85.3% versus 29.8%; in Construction it yields $s_i$ 7 versus 49.1% and $s_i$ 8 versus 3.88%; and Token Cost falls from 10.30 to 1.79 (Dong et al., 2024).

GraphTrafficGPT uses a Brain Agent to decompose traffic-management queries into a DAG whose nodes are assigned to specialized agents for data retrieval, analysis, visualization, simulation, and optimization, then executes each topological batch in parallel (Taleb et al., 17 Jul 2025). The reported gains are a 50.2% reduction in token consumption, a 19.0% reduction in average response latency, and up to 23.0% improvement in simultaneous multi-query efficiency (Taleb et al., 17 Jul 2025).

3. Runtime tracing, causal attribution, and interpretability

A second major use of agent dependency graphs is post-hoc diagnosis. AgentTrace reconstructs a causal DAG from execution logs, with sequential edges, communication edges, and data-dependency edges, and identifies upstream candidates from an error node by bounded breadth-first backward traversal (Wang, 16 Mar 2026). Candidate ranking is a weighted sum of five feature groups,

$s_i$ 9

with learned weights $(v_i\to v_j)$ 0 (Wang, 16 Mar 2026). The implementation runs in overall $(v_i\to v_j)$ 1; on traces of 8–15 steps it takes on average 114 ms $(v_i\to v_j)$ 2 end-to-end on a modern 16-core CPU (Wang, 16 Mar 2026).

GraphTracer replaces temporal attribution with information-flow analysis. Its Information Dependency Graph has nodes $(v_i\to v_j)$ 3 for time step, producing agent, and content, and an edge $(v_i\to v_j)$ 4 means that $(v_i\to v_j)$ 5 explicitly cited or built upon $(v_i\to v_j)$ 6 (Zhang et al., 12 Oct 2025). Root-cause localization begins from failure nodes, collects ancestors, scores candidates by out-degree and betweenness-derived Impact, and validates top candidates by counterfactual correction and downstream re-execution (Zhang et al., 12 Oct 2025). On the Who When benchmark, GraphTracer-8B achieves 74.91% agent-level accuracy versus 63.73% for the best prior method, 28.63% step-level accuracy versus 20.68%, and 69.74% / 27.97% without ground-truth answers; in production frameworks it yields 4.8% to 14.2% end-to-end performance gains (Zhang et al., 12 Oct 2025).

GRADE argues that the dependency layer and the execution layer should be separated rather than conflated. Across six corpora, the dependency-shape feature block improves failure prediction over flat size features on the “size-weak” corpora: tau-bench from 0.583 to 0.614 ROC-AUC, SWE-agent from 0.628 to 0.713, and SWE-Gym from 0.663 to 0.805 (Zhao, 22 Jun 2026). Under leave-one-corpus-out transfer, the dependency-only model stays above chance on all six held-out corpora while flat run-size features invert on tau-bench and SWE-Gym (Zhao, 22 Jun 2026). For “Who and When” fault localization, the execution layer alone improves top-1 from 0.159 under a position prior to 0.211, top-3 from 0.516 to 0.614, and MRR from 0.407 to 0.454 (Zhao, 22 Jun 2026).

A related interpretability result shows that tool-call dependency structure is linearly decodable from LLM residual streams. The probe defines $(v_i\to v_j)$ 7 when the output text of call $(v_i\to v_j)$ 8 supplies at least one argument to call $(v_i\to v_j)$ 9, trains a logistic edge probe over concatenated call-boundary residual representations, and outperforms both a Hewitt–Liang random-label control and a positional baseline (Sun et al., 25 May 2026). On the primary domain, the positional-only baseline attains AUROC $s_j$ 0, while adding residual features yields a non-positional contribution of $s_j$ 1; under a stricter schema-typed oracle, direct AUROC rises to 0.947 and the non-positional contribution to $s_j$ 2 (Sun et al., 25 May 2026). Replication across $s_j$ 3-bench retail, ToolHop, ComplexFuncBench, TaskBench, and BFCL multi-turn shows that the transitive-edge signal is strongest in interactive multi-hop settings and vanishes in single-shot planning (Sun et al., 25 May 2026). This suggests that some agent dependency graphs are not merely external bookkeeping artifacts but are represented internally in model activations.

4. Static analysis, governance, and skill dependency infrastructures

In static program analysis, the graph is recovered from source code rather than execution traces. AgentFlow parses host-language ASTs, recognizes framework constructs such as Agent(...), @function_tool, and handoff(...), performs alias resolution via YASA, and emits entity, component-binding, control-flow, and data-flow facts (Wang et al., 2 Jul 2026). These facts populate the component, control, and data subgraphs of the ADG, and all edges are over-approximations of possible runtime dependency under framework semantics (Wang et al., 2 Jul 2026). On AgentZoo, a corpus of 5,399 real-world agent programs, AgentFlow recovers richer entities and dependencies than AST-based baselines, produces Agent BOMs for 98/100 projects, and uncovers 238 taint-style prompt-to-tool risks across the full corpus, with a median end-to-end analysis time of 14.17 s and a 95th percentile of 163.5 s (Wang et al., 2 Jul 2026).

At the ecosystem level, “Skills Are Not Islands” defines an Agent Skill Supply Chain as a directed, typed graph $s_j$ 4 with skill nodes, package nodes, and external-service nodes, and edge channels SKILL_DEP, PKG_DEP, USES_SERVICE, and transitive package-to-package dependencies (Jia et al., 1 Jul 2026). SkillDepAnalyzer extracts dependency evidence from YAML front matter, natural-language instructions, and code blocks; verifies packages through local environments or registries; recursively expands skill dependencies; and outputs a SkillBOM with canonicalized components and relationships (Jia et al., 1 Jul 2026). Applied to over 1.43 million skills, this analysis finds front matter in 99.55% of skills but “dependencies” fields in only 1.40%, license fields in 11.25%, version fields in 20.12%, and exact name collisions in 58.73%; 36.60% of skills use at least one dependency channel, the skill reuse Gini coefficient is 0.925, package reuse Gini is 0.944, p99 total dependency amplification is 130.5×, and the maximum package amplification is 1,754× (Jia et al., 1 Jul 2026). Security signals are frequently transitive-only: for example, the reported ‘axios’ compromise reaches 3,413 roots, 98.01% via transitive package dependencies (Jia et al., 1 Jul 2026).

Graph of Skills addresses a related but distinct problem: inference-time retrieval from very large skill libraries. It builds an offline typed, weighted, directed graph with relation types $s_j$ 5, then performs hybrid semantic-lexical seeding, reverse-weighted Personalized PageRank, reranking, and context-budgeted hydration (Liu et al., 7 Apr 2026). The diffusion operator mixes forward and reverse transitions so that high-level skills can propagate relevance to semantically weak prerequisites, and the final bundle is greedily selected under a fixed token budget (Liu et al., 7 Apr 2026). On SkillsBench and ALFWorld, GoS improves average reward by 43.6% over full skill loading while reducing input tokens by 37.8%, and ablations from 200 to 2,000 skills show better balance among reward, token efficiency, and runtime than both full loading and simple vector retrieval (Liu et al., 7 Apr 2026).

5. Coordination structure in multi-agent reinforcement learning and scheduling

In cooperative MARL, action dependency graphs specify how one agent’s action conditions another’s policy. The ADG framework of Ding et al. defines a directed acyclic graph $s_j$ 6 such that

$s_j$ 7

where $s_j$ 8 is the in-neighborhood of agent $s_j$ 9 (Ding et al., 1 Jun 2025). Under a coordination graph $s_i$ 0, the key sufficient condition

$s_i$ 1

guarantees that any $s_i$ 2-locally optimal policy is globally optimal (Ding et al., 1 Jun 2025). The resulting AD-MPI algorithm converges in finitely many steps to a globally optimal policy under the paper’s assumptions, and in coordination polymatrix games sparse ADGs achieve 100% optimality on line, ring, star, and mesh topologies while running 2–3× faster per step than dense auto-regressive ADGs (Ding et al., 1 Jun 2025). On ATSC and SMAC MMM2, sparse ADGs improve both final performance and convergence speed relative to empty or dense dependencies (Ding et al., 1 Jun 2025).

Action-Graph Policies move the dependency graph from agents to action choices. The graph nodes are action nodes $s_i$ 3 for each agent-action pair, and attention-based message passing produces per-agent coordination contexts $s_i$ 4, yielding

$s_i$ 5

The paper proves that $s_i$ 6, so AGP is strictly more expressive than fully independent policies (Gupta et al., 19 Feb 2026). Empirically, AGP reaches about 95–96% success on Top-K coordination matrix games where baselines cluster near the $s_i$ 7 independent bound, remains about 96% under anti-coordination penalties, and outperforms IQL, VDN/QMIX, DCG/DICG, MACPF, and FOP across six Multi-Agent Particle Environments (Gupta et al., 19 Feb 2026).

LGC-MARL brings the dependency graph back to agent-level execution. At each step, an LLM planner emits a DAG $s_i$ 8 whose nodes are the $s_i$ 9 agents and whose edges encode “who must act before whom,” then an RNN-based actor-critic meta-policy samples each action conditioned on the actions of parent agents (Jia et al., 13 Mar 2025). The planner may iteratively revise the graph through an ask–critique–revise loop with a critic LLM, and the joint policy factorizes as

$a_i=(i_i,f_i,o_i)$ 0

On four AI2-THOR scenes with $a_i=(i_i,f_i,o_i)$ 1, full LGC-MARL outperforms centralized LLM, LLM dialogue, and ablations, reaching success rates up to 0.92 versus 0.68 and 0.60, reducing average completion time to about 66 s versus 155 s, and cutting normalized token cost by 80–90% to about 1.8 versus 10.7 (Jia et al., 13 Mar 2025).

An earlier, non-LLM use of the same idea appears in multi-AGV scheduling. There, an Action Dependency Graph encodes event ordering constraints for route execution, distinguishes intra-agent and inter-agent edges, and allows certain Type 2 edges to be switched online through an MILP while preserving acyclicity and deadlock freedom (Berndt et al., 2020). On realistic intralogistics simulations with 30–70 AGVs and random disturbances, the feedback scheme improves average completion times by up to 10–12% at large delays, with typical solve times under 50 ms for $a_i=(i_i,f_i,o_i)$ 2 when $a_i=(i_i,f_i,o_i)$ 3 (Berndt et al., 2020).

6. Methodological issues, common confusions, and open problems

A recurring confusion is to equate dependency with temporal order. Multiple papers explicitly reject that equivalence. GraphTracer motivates IDGs precisely because errors propagate across agents in ways that temporal attribution misses (Zhang et al., 12 Oct 2025). AgentTrace adds communication and data-dependency edges beyond sequential adjacency (Wang, 16 Mar 2026). GRADE distinguishes the execution layer, which is “read from the trace for free,” from the dependency layer, which is “rarely logged” and must be observed, declared, or inferred (Zhao, 22 Jun 2026). AgentFlow likewise separates component, control-flow, and data-flow dependencies, and treats recovered edges as static over-approximations of possible runtime behavior rather than observed behavior itself (Wang et al., 2 Jul 2026).

A second misconception is that any graph representation is interchangeable. The literature shows otherwise. Edge direction differs between GAP and Aria; GRADE’s dependency edges carry observability grades; AgentFlow’s ADG is a triple of graphs rather than one graph; skill-supply-chain graphs are typed, heterogeneous, and recursive; and MARL action-dependency graphs encode policy conditioning rather than informational provenance (Wu et al., 29 Oct 2025, Wang et al., 6 Oct 2025, Zhao, 22 Jun 2026, Jia et al., 1 Jul 2026, Ding et al., 1 Jun 2025). A plausible implication is that transfer of algorithms across ADG variants depends less on the term “dependency graph” than on the exact node semantics, edge semantics, and observability model.

The papers also identify substantive limitations. In GRADE, the dependency layer adds reliable lift on “size-weak” corpora but little or nothing on “size-strong” corpora, and the authors provide a more in-depth analysis of why generic graph neural networks may misread the dependency layer, unlike their feature-based alternative (Zhao, 22 Jun 2026). In ADG-based MARL, global-optimality guarantees assume a known coordination graph and full observability of the relevant state or parent actions; extending the theory to POMDPs, dynamic graphs, hypergraphs, and automatic ADG learning remains open (Ding et al., 1 Jun 2025). In skills infrastructure, inspecting only the root skill misses most security-relevant exposures because many signals are transitive-only, motivating typed dependency manifests, first-class cluster management, risk-warning audit commands, and lockfile-like records (Jia et al., 1 Jul 2026).

Taken together, the literature presents Agent Dependency Graphs as a unifying but not uniform abstraction. Their central contribution is to convert implicit reliance structure into explicit graph objects that can be searched, scheduled, verified, ranked, repaired, or optimized. The strongest empirical results arise when that explicit structure captures dependencies that sequential traces, flat metadata, or independent policies do not already reveal.