Task–Skill Dependency Graph Overview

• Task–Skill Dependency Graphs are formal models that represent tasks and skills as nodes with directed edges capturing compositional, sequential, and dependency relationships.
• They enable efficient planning, hierarchical policy composition, and skill transfer across diverse applications such as reinforcement learning, robotics, multi-agent systems, and education.
• Construction methods include community detection, graph-based knowledge tracing, parameterized matching, and LLM-driven extraction to create scalable and interpretable dependency structures.

A Task–Skill Dependency Graph (TSDG) is a formalism that encodes the relationships between tasks and the skills required for their completion, typically as a directed graph where nodes represent skills (or options) and edges express compositional, sequential, or dependency relations. This abstraction enables principled decomposition, flexible sequencing, and improved transfer for complex task domains across reinforcement learning, robotics, multi-agent systems, education, and machine learning.

1. Formal Definitions and Variants

At its core, a TSDG consists of nodes and directed edges where:

• Nodes denote skills, options, primitive actions, or tasks, depending on context.
• Edges capture compositional structure (e.g., a high-level skill calls a lower-level skill), precedence constraints (“must happen before”), geometric/feasibility relations, or parameter-sharing between tasks.

Several canonical classes are prominent:

• Hierarchical Skill Graphs: Multi-level DAGs mapping coarse-to-fine skills (Evans et al., 2023), with rooted trees or layered structures by abstraction granularity.
• Bipartite Task–Skill Graphs: Nodes partitioned as tasks and skills, with edges reflecting required skills for each task (e.g., question–skill incidence matrices in education (Yang et al., 2020), task–adapter subgraphs in ML (Wang et al., 2024)).
• Weighted Matching Graphs: Edge weights denote strength of dependency (learned matching matrices in production optimization (Xie et al., 2023), skill-sharing in LLMs (Panigrahi et al., 2023)).
• Acyclic Precedence DAGs: Skills as nodes, edges encoding temporal/causal prerequisites for multi-agent planning (Obata et al., 2024).
• Multi-relational Graphs: Nodes as environments, tasks, or skills, with meta-relations for transfer (Zhu et al., 9 Jul 2025).

A precise TSDG definition varies by field. In RL (Evans et al., 2023), nodes are options with policies $\pi$; an edge $o^{(\ell)} \rightarrow o'^{(\ell-1)}$ indicates the higher-level policy invokes a lower-level skill. In robotics (Guo et al., 2021, Qi et al., 2024), nodes are parameterized skills; edges encode feasible transitions and the geometric/semantic constraints permitting them.

2. Algorithmic Construction and Learning

Multiple families of algorithms exist for constructing TSDGs, noted for their automation and scalability:

• Community Detection in MDP State Graphs: Partition the Markov state-transition graph using modularity maximization (Louvain algorithm) at multiple resolutions (Evans et al., 2023). Each cluster at level $\ell$ becomes a skill $o_{i \to j}^{(\ell)}$, with options recursively composed into a DAG.
• Graph-based Knowledge Tracing: Build a bipartite incidence matrix $R$ from question–skill mappings, augment to adjacency $A$, and apply GCNs to propagate high-order dependencies (Yang et al., 2020).
• Geometric Task Network Induction: From demonstration-planned traces $\Xi$, extract skill–skill transition edges; fit parameterized Gaussian mixture models to encode feasible geometric transitions as edge labels (Guo et al., 2021).
• Matching Matrix Optimization: In skill–task matching models (e.g., personnel-task assignment), iteratively update $M_{ij}$ by backpropagating profit/loss gradients. Threshold or normalize $M$ post-training to yield a bipartite TSDG (Xie et al., 2023).
• Skill Localization in LMs: For each NLP task, extract minimal mask regions (grafting) of model parameters responsible for the task; compute task–task edge weights as Jaccard overlaps of these sparse masks (Panigrahi et al., 2023).
• Multi-Adapter Routing: In parameter-efficient transformer PEFT settings, train a dense allocation matrix $W_{\text{skill}}$ linking abstract tasks to shared skill-adapters via Gumbel-sigmoid relaxation, producing a bipartite soft assignment graph (Wang et al., 2024).
• Graph-Based Multi-Agent Skill Matching: Define a multi-relational, directed graph of entities (environments, tasks, skills); train via a knowledge graph embedding model (e.g., TransH) to score triplets and enable flexible, compositional reuse (Zhu et al., 9 Jul 2025).
• LLM-Driven Precedence Graphs: Use an LLM to generate, via few-shot and chain-of-thought prompting, a skills list and acyclic dependency graph reflecting precedence for multi-robot planning; enforce edges as “must happen before” constraints. Coupled with LP solvers for optimal allocation (Obata et al., 2024).

3. Functional Roles: Inference, Planning, and Interpretation

TSDGs serve as the backbone for efficient inference and planning across domains:

• Hierarchical Policy Composition: In RL, a TSDG structures agent behavior, enabling higher-level skills to invoke compositions of lower-level skills, reducing sample complexity, and allowing rapid adaptation to longer task horizons (Evans et al., 2023, Zhu et al., 9 Jul 2025). Policy execution traverses the DAG from root down, choosing skills at the relevant abstraction.
• Sequential Reasoning and Precedence Tracking: In robotics and multi-agent settings, a TSDG encodes which skills may be executed in parallel or must validate prerequisite completions before execution, facilitating optimized scheduling and allocation (Obata et al., 2024, Qi et al., 2024).
• Skill Transfer and Adapter Reuse: Encoding which tasks share skills or parameter regions allows for forward transfer, multi-task adaptation, and continual learning. In multi-adapter LMs, the learned allocation matrix enables conditional skill recombination for novel tasks (Wang et al., 2024, Panigrahi et al., 2023).
• Dependency-Aware Knowledge Tracing: In educational systems, a question–skill bipartite graph allows embedding propagation, aiding in countering data sparsity and improving prediction of performance for rare or composite tasks (Yang et al., 2020).
• Explainability and Failure Attribution: TSDG structure exposes which lower-level components are responsible for task failures or success: e.g., in parameterized robotics, failure to find a feasible edge is interpreted as a model insufficiency or sensory error (Guo et al., 2021); in adapters or LMs, mask overlap can indicate cross-task generalization potential (Panigrahi et al., 2023).

4. Empirical Impact and Performance Analyses

A comprehensive body of empirical studies demonstrates the substantial advantages of explicit TSDG representations:

• In RL, multi-level Louvain TSDGs accelerate agent learning by two- to fivefold compared to flat or single-level skill baselines, with the benefit persisting as state-space cardinality increases and the hierarchy depth scales sub-logarithmically (e.g., up to eight levels in $10^6$-state Office domains) (Evans et al., 2023).
• Flat arrangements (where every skill calls primitives directly) incur significant slowdown, confirming that hierarchical DAG architectures are strictly advantageous for compositional environments (Evans et al., 2023).
• In multi-task MARL settings, skill graphs decouple high-level structure from low-level control and permit flexible blending, outperforming hierarchical MAPPO in both simulation and real-robot experiments; success rates approach $100\%$ and are robust to task and environment changes (Zhu et al., 9 Jul 2025).
• Adapter-based TSDGs improve parameter efficiency and transfer: tasks with shared skill allocations require fewer updates and enable smaller models to match the performance of larger ones; zero-shot and unseen task generalization measurements show substantial improvements (e.g., +10 Rouge-1 points in LM summarization) (Wang et al., 2024).
• In continual and multi-task NLP, localized skill masks (TSDG edges as mask overlaps) prevent catastrophic forgetting and recover known task clusters without joint re-training (Panigrahi et al., 2023).
• For multi-robot LLM planning, the precedence DAG plus LP enables significant gains: maximum success-rate increases of $0.82$ when planning table-top tasks with minor variations compared to pure LLM or decentralized dialog baselines (Obata et al., 2024).

5. Advanced Extensions: Embedding, Constraint, and Transfer Structures

Modern TSDGs embed a range of rich structure:

• Parameterized/Conditional Edges: In Geometric Task Networks, edges are annotated with constraint models (TP-GMMs) encoding geometric feasibility, yielding runtime transition scores for action selection (Guo et al., 2021).
• Multi-relational and Soft Edges: Using knowledge graph embedding learning (TransH), soft plausibility is scored based on entity similarity, enabling partial credit and blends when a perfect skill match is unavailable (Zhu et al., 9 Jul 2025).
• Multi-Modal Node Types and Edge Labels: Robotics libraries distinguish task graph (task/subtask/action), scene graph (objects, geometric/physical relations), and state graph (mapping abstract tasks to observed world states), each with bespoke edge labels (contain, require, obtain, support) (Qi et al., 2024).
• Automated Construction from Unstructured Data: LLMs can induce both ordered skill sequences and acyclic dependency graphs from natural-language instructions, iteratively reparsing cycles and ambiguous dependencies (Obata et al., 2024).
• Sparse Subgraph Extraction: Thresholding or top-$k$ row selection in allocation matrices or matching matrices produces interpretable, human-readable dependency subgraphs suitable for visualization or direct analysis (Xie et al., 2023, Wang et al., 2024).

6. Common Patterns, Diagnostics, and Applications

A comparison across domains reveals several shared motifs:

Domain	Node Types	Edge Semantics	Construction Principle
RL/Options (Evans et al., 2023)	Options/Skills	“Calls-to”/DAG	Modularity maximization
Robotics (Guo et al., 2021, Qi et al., 2024)	Primitive/Parametrized Skills, Objects, Subtasks	Feasibility, Containment, Precedence	Demonstration + geometric learning
Multi-agent (Zhu et al., 9 Jul 2025)	Tasks, Skills, Environments	Relation (multi-type)	KGE scoring (TransH)
NLP/Adapters (Panigrahi et al., 2023, Wang et al., 2024)	Tasks, Parameters, Adapters	Parameter/subset overlap, allocation	Mask optimization, Gumbel gates
Education (Yang et al., 2020)	Questions, Skills	Bipartite requirement	Manual/incidence, GCN
Multi-robot LLM planning (Obata et al., 2024)	Skills	Precedence (DAG)	LLM prompt + LP
Enterprise optimization (Xie et al., 2023)	Skills, Tasks	Weighted matching	Iterative regression

Evaluation of a TSDG's quality relies on:

• Hierarchical clustering and dendrogram analysis (e.g., task group recoveries in $W_{\text{skill}}$, matching of task clusters to skills).
• Performance improvement metrics (learning speed, success rate, catastrophic forgetting reduction).
• Visualization of block or sparse dependency structure.

Widespread applications include: hierarchical RL option discovery (Evans et al., 2023), explainable robotic manipulation (Guo et al., 2021), knowledge transfer in multi-agent MARL (Zhu et al., 9 Jul 2025), skill assignment in production systems (Xie et al., 2023), adapter composition in LLMs (Wang et al., 2024), and efficient multi-robot scheduling (Obata et al., 2024).

7. Open Challenges and Future Directions

The formalism of the Task–Skill Dependency Graph is rapidly proliferating, yet ongoing research faces several outstanding challenges:

• Joint Optimization Across Abstraction Levels: Many systems decouple high- from low-level learning; methods that learn the TSDG and fine-tune policies jointly are under active development (Zhu et al., 9 Jul 2025).
• Scalable Induction from Unstructured Data: Robustness and scalability in LLM-based graph extraction, particularly in the presence of noisy or ambiguous skill references (Obata et al., 2024).
• Generalization and Domain Adaptation: Determining the TSDG transferability across domains, environments, and agents remains an open problem—edge softness/embedding and modularity play key roles (Wang et al., 2024).
• Causal and Probabilistic Extensions: Extending edge semantics beyond strict dependency to probabilistic, weighted, or even counterfactual relations.
• Explainability and Intervention: Formal diagnostic tools for tracing errors or insufficient performance to specific TSDG nodes or edges, and for suggesting improvements (Guo et al., 2021).
• Integration with Classic and Neural Optimization: Blending LP/ILP scheduling with neural TSDG construction for hybrid reasoning and real-time execution (Obata et al., 2024).

The TSDG offers a rigorous, interpretable, and empirically validated foundation for encoding and analyzing the compositional structure of skills, enabling rapid learning, flexible sequencing, forward transfer, and explainability across complex multi-task environments (Evans et al., 2023, Guo et al., 2021, Panigrahi et al., 2023, Wang et al., 2024, Zhu et al., 9 Jul 2025, Qi et al., 2024, Xie et al., 2023, Obata et al., 2024, Yang et al., 2020).