Skill Graph: Structured Competence Representation

• Skill graph is a family of graph-based representations that structure and interconnect reusable competencies with explicit nodes and edge semantics across various domains.
• It is applied in fields such as agent systems, robotics, autonomous driving, competitive games, and labor-market analytics by tailoring node definitions and edge roles to specific tasks.
• Skill graph frameworks facilitate structured skill retrieval, execution, and adaptation while addressing challenges like semantic fragmentation, partial formalization, and graph evolution.

“Skill graph” is a family of graph-based representations used to organize, retrieve, execute, monitor, or improve skills, but the term does not denote a single canonical formalism across the literature. In agent systems, it can mean a typed directed execution graph over reusable procedures; in robotics, a graph of executable skills linked by preconditions and postconditions; in autonomous driving, a directed acyclic graph of capability dependencies; in labor-market analytics, a heterogeneous occupation–skill knowledge graph; in competitive games, an undirected weighted skill-gap graph over players; and in some reasoning systems, a graph of atomic natural-language heuristics or evolving skill memories (Blumenfeld et al., 3 Jun 2026, Yu et al., 13 Mar 2026, Jatzkowski et al., 2021, Groot et al., 2021, Wang, 2023, Yang et al., 10 Apr 2026).

1. Conceptual scope and major variants

Across the cited literature, the shared intuition is that skills are better handled as structured objects with explicit relations than as isolated entries or free-form prose. What changes from domain to domain is the ontology of nodes, the meaning of edges, and whether the graph is descriptive, executable, or used only at inference time.

Domain	Graph object	Primary role
Agent skills	Skill/Step execution graph	Execution, debugging, governance
Robotic assembly	Directed graph of instantiated skills	Planning, execution, improvement
Automated vehicles	Capability DAG	Online monitoring, design, verification
Labor market	Occupation–skill KG	Matching, pathfinding, link prediction
Competitive games	Player skill-gap graph	Embedding and rating adjustment
LLM skill libraries	Typed inter-skill graph	Retrieval, conflict detection, orchestration

In the Agent Instruction Protocol, a skill is a directed execution graph with a top-level Skill node and multiple Step nodes; steps expose typed inputs and outputs, optional script bodies, prose references, and control annotations such as depends_on, parallel, and one_of, with the overall package schema-validated in YAML (Blumenfeld et al., 3 Jun 2026). In robotic assembly, a skill is formalized as a tuple containing a verb, nouns, policy, preconditions, postconditions, and evaluator, and the graph links skills when the post-condition of one implies the pre-condition of another (Yu et al., 13 Mar 2026). In automated driving, skill graphs are directed acyclic graphs whose nodes are vehicle capabilities grouped into seven categories and whose edges denote “depends on” relations (Jatzkowski et al., 2021).

Other uses are more relational than executable. The labor-market graph links occupations and skills, enriched with job-posting evidence, and then supports link prediction, node similarity, shortest paths, and TF-IDF-style distinctiveness analysis (Groot et al., 2021). The competitive-games formulation uses an undirected weighted graph over players, where an edge exists if two players have met and the weight encodes a reliability-adjusted notion of skill-gap closeness (Wang, 2023). GeoSkill defines a task-specific Skill-Graph over retrieved atomic natural-language geographic reasoning skills, with directed prerequisite edges used to organize coarse-to-fine geolocation reasoning (Yang et al., 10 Apr 2026).

A plausible implication is that “skill graph” is best treated as an umbrella term for graph-structured representations of reusable competence, rather than as a settled technical standard.

2. Structural semantics: nodes, edges, and execution meaning

The most important distinctions among skill graphs concern what a node denotes and what an edge commits the system to. In some papers, nodes are executable operators; in others they are latent heuristics, occupations, or players. Likewise, edges may encode hard prerequisites, typed dataflow, similarity, co-occurrence, specialization, conflict, or feasibility.

Several agent and robotics papers make the node interface explicit. In AIP, a step can be backed either by a deterministic script or by natural-language guidance, and typed intermediate values such as lc-path : string, column-map : object, or detection : object are passed along labeled edges; the paper stresses that the artifact is a directed execution graph rather than merely a dataflow graph (Blumenfeld et al., 3 Jun 2026). In robotic assembly, each node contains semantic and operational content—verb, instantiated nouns, executable policy, preconditions, postconditions, and evaluator—and feasibility of a transition is defined by

$$\mathcal{P}_{\text{post}}(s_i,z) \Rightarrow \mathcal{P}_{\text{pre}}(s_j,z).$$

The graph is therefore an executable transition system over a shared state space rather than a taxonomy of actions (Yu et al., 13 Mar 2026).

By contrast, other papers emphasize typed relational structure over execution. GoS defines

$G=(V,E,w,\phi),$

where nodes are normalized executable skill records and edge types are dep, wf, sem, and alt; GoSkills assumes a typed skill graph with dependency, workflow, semantic, artifact, or alternative relations and then lifts it to a group graph over anchor-centered skill groups (Liu et al., 7 Apr 2026, Zeng et al., 7 May 2026). SkillDAG defines

$G=(V,E,\tau)$

over skills with five relation types—depends_on, specializes, composes_with, similar_to, and conflicts_with—and reserves acyclicity only for the depends_on/specializes backbone (Bai et al., 2 Jun 2026). SkillGraph for agent RL similarly uses a directed graph with prerequisite, enhancement, and co-occurrence edges, together with edge weights updated from trajectories (Li et al., 12 May 2026).

In labor-market and rating applications, edges carry different semantics again. The occupation–skill graph combines taxonomy edges, ESCO-to-ISCO mappings, and weighted occupation–skill associations derived from posting co-occurrence (Groot et al., 2021). The GElo skill-gap graph uses

$G=(V,E)$

over players, with edge weights derived from repeated win-loss imbalance; numerically, larger weights correspond to smaller estimated skill gaps, and those weights bias random walks used for DeepWalk-style embedding (Wang, 2023).

This diversity matters because graph algorithms are only meaningful relative to edge semantics. A shortest path through occupation similarity is not the same object as a repair neighborhood in an executable skill DAG, and a conflict edge in SkillDAG has a very different operational status from a data edge in GraSP or AIP.

3. Agentic LLM systems: retrieval, orchestration, execution, and repair

Recent agent papers use skill graphs to solve a common problem: large skill libraries create a structural selection problem that semantic top-$K$ retrieval or full-library prompting handles poorly. The proposed solutions differ in how much structure they expose, but all move away from flat lists.

AIP converts prose skills into schema-validated execution graphs and reports that compiling human-curated skills into this form raised Claude Sonnet’s mean task reward from $0.599$ to $0.705$, with pass rate rising from $53.3\%$ to $67.4\%$ across 27 real agent tasks from SkillsBench; the Wilcoxon signed-rank test gave $p=0.011$, and the win/tie/loss count was $G=(V,E,w,\phi),$0. The same graph addressability supported precise repair of authored skill failures, including one task that moved from $G=(V,E,w,\phi),$1 to $G=(V,E,w,\phi),$2 after a specification change and recompilation with zero regressions (Blumenfeld et al., 3 Jun 2026).

GoS treats the skill graph as an inference-time structural retrieval layer. It constructs a typed directed graph offline from skill packages and, at inference time, retrieves a bounded dependency-aware bundle through hybrid semantic-lexical seeding, reverse-aware Personalized PageRank, reranking, and budgeted hydration. On SkillsBench and ALFWorld, it improves average reward by $G=(V,E,w,\phi),$3 over the vanilla full skill-loading baseline while reducing input tokens by $G=(V,E,w,\phi),$4, and its main role is to surface structurally necessary prerequisites that plain vector retrieval misses (Liu et al., 7 Apr 2026). GoSkills retains the graph substrate but changes the retrieval object from a flat list or bundle to an anchor-centered group plan rendered as a fixed execution contract with Start, Support, Check, and Avoid fields. On SkillsBench, paired bootstrap against Graph of Skills showed a reward delta of $G=(V,E,w,\phi),$5 percentage points with $G=(V,E,w,\phi),$6 CI $G=(V,E,w,\phi),$7 and a runtime delta of $G=(V,E,w,\phi),$8s with $G=(V,E,w,\phi),$9 CI $G=(V,E,\tau)$0; visible-requirement coverage was maintained under a budget of fewer than four presented skills (Zeng et al., 7 May 2026).

SkillDAG exposes the graph even more directly as an agent-callable structural retrieval interface. A search call returns top vector matches, typed-edge neighbors found by bounded BFS, and one-hop conflict signals, while a propose-then-commit protocol lets the agent register execution-backed edges online. On MiniMax-M2.7, SkillDAG reaches $G=(V,E,\tau)$1 success on ALFWorld and $G=(V,E,\tau)$2 reward on SkillsBench, exceeding the strongest reported GoS baseline by $G=(V,E,\tau)$3 and $G=(V,E,\tau)$4 points respectively; on intrinsic SkillsBench retrieval, Ret@K rises from $G=(V,E,\tau)$5 to $G=(V,E,\tau)$6 under matched queries (Bai et al., 2 Jun 2026). GraSP pushes this line of work from retrieval into execution: it compiles retrieved skills into an executable typed DAG with state, data, and order edges, performs node-level precondition and postcondition verification, and repairs failures locally with five typed operators—Rebind, InsertPrereq, Substitute, Rewire, and Bypass. Across ALFWorld, ScienceWorld, WebShop, and InterCode, GraSP improves reward by up to $G=(V,E,\tau)$7 points over the strongest baseline while cutting environment steps by up to $G=(V,E,\tau)$8; the paper attributes the benefit to explicit causal dependencies and locality-bounded repair, contrasting flat $G=(V,E,\tau)$9 replanning with graph-local $G=(V,E)$0 repair (Xia et al., 20 Apr 2026).

A common conclusion across these papers is that skill abundance shifts the bottleneck from skill acquisition to structural orchestration. Graph compilation, typed relations, explicit prerequisites, and local repair are the recurrent mechanisms by which these systems attempt to make large skill libraries usable.

4. Self-evolving skill graphs and graph-shaped reasoning memories

A second strand of work treats the skill graph not primarily as a retriever substrate but as an evolving memory whose topology changes with experience. Here the graph mediates capability growth, audit, or query-conditioned collaboration.

SkillGraph for visual multi-agent systems couples a Multimodal Graph Transformer with a self-evolving Skill Bank. Each agent is assigned an active skill represented by a trigger, strategy text, running accuracy, failure buffer, and version counter; MMGT then predicts a query-conditioned directed communication DAG over agents using image content, question semantics, and current skill embeddings. The graph is trained by policy gradients over sampled collaboration graphs, while a Skill Designer modifies or creates skills from recurring failures. Empirically, SkillGraph improves over fixed-topology baselines across MMBench, MathVista, RealWorldQA, and InfoVQA, and the improvements persist across five common MAS structures, four backbones, and model scales from $G=(V,E)$1B to $G=(V,E)$2B, with especially strong gains on MathVista and RealWorldQA (Nie et al., 19 Apr 2026).

GeoSkill defines a different kind of Skill-Graph: a task-specific graph

$G=(V,E)$3

over retrieved atomic natural-language geolocation heuristics, where a directed edge means the conclusion of one skill is a prerequisite for another. It initializes from expert trajectories, begins with $G=(V,E)$4 foundational skills, and then evolves through synthesis, merging, and pruning of skills and relations using multiple reasoning rollouts on image-coordinate pairs. On GeoRC, the full graph-based system reaches $G=(V,E)$5 at 10km, $G=(V,E)$6 at 25km, $G=(V,E)$7 at 200km, and reasoning-faithfulness F1 of $G=(V,E)$8; across evolution steps, the skill inventory changes from $G=(V,E)$9 while F1 improves from $K$0 to $K$1 (Yang et al., 10 Apr 2026).

ASG-SI pushes graph evolution into governance. It defines an audited skill graph as a directed multigraph whose nodes are promoted reusable skills with explicit interfaces, canonical implementations, verification reports, and provenance, while edges encode composition constraints, dependency ordering, and guarded fallbacks. Improvements are extracted from successful trajectories, compiled into candidate skills, and promoted only after verifier-backed replay and contract checks. The paper presents a complete architecture, threat model, and runnable prototype, but it does not report benchmark tables; its main contribution is to make graph growth auditable and rewards reconstructible from replayable evidence rather than opaque parameter drift (Huang et al., 28 Dec 2025).

These papers differ substantially in mechanism, but they share a strong claim: graph structure can serve as an external memory that is editable, inspectable, and versioned, rather than being hidden inside weight updates alone.

5. Robotics, autonomous systems, and embodied control

In embodied domains, skill graphs usually carry stronger execution semantics than in retrieval-oriented agent papers. Skills are bound to controllers, perception modules, or capability monitors, and edges often encode feasibility or dependency rather than semantic similarity.

In robotic assembly, the Skill Graph is the central representation unifying symbolic task specification, executable policies, evaluators, and long-term improvement. Skills are verb-based, grounded by nouns such as robots, objects, and environments, and connected when postconditions satisfy downstream preconditions. The system distinguishes atomic and meta skills, plans with best-first search over grounded skills, and can transform sequential skill plans into a Temporal Plan Graph for asynchronous multi-robot execution. In LEGO experiments, a manipulation-only graph with seven atomic skills and three meta skills was extended with visual post-condition classifiers, a visual pre-condition checker, and a new anomaly-detection perception skill; after these augmentations, all demonstrated designs—Faucet, Fish, Vessel, and Guitar—were completed successfully in the reported trials (Yu et al., 13 Mar 2026).

A related but different robotics use appears in graph world models. The BIM-based world-model paper represents spaces, walls, openings, materials, and meshes in an RDF graph and then generates skill-specific maps on demand using robot parameters such as lidar height or robot height. For localization, the system slices selected geometry at sensor height; for navigation, it uses a cuboid up to robot height. On the Neuron building, the graph contains $K$2 RDF triples with 11,500 elements and 10,822 meshes, showing that skill-conditioned map generation can operate at building scale (Vos et al., 2024).

In autonomous driving, skill graphs are directed acyclic graphs for online capability monitoring. Nodes are organized into seven categories—system, behavioral, planning, perception, data acquisition, action, and actuation skills—and the graph for a given behavior is assembled from a reusable behavior-specific base graph plus ODD-dependent additions inferred from scene elements represented in an ontology. The paper’s evidence is primarily expert review: automatically generated graphs were judged sound in general construction, and comparison with manual graphs revealed inconsistencies and missing dependencies in the manual versions (Jatzkowski et al., 2021).

Other embodied papers adopt graph structure for skill reuse under adaptation. RSG for quadruped robots builds a KG-like graph over skills, tasks, and environments, with relation types $K$3 and $K$4 scored by a TransH-style embedding model. The initial RSG stores approximately 320 fundamental skills in about 640MB, and at inference time the joint score

$K$5

determines whether to reuse a skill directly, compose several via Bayesian optimization, or fine-tune by RL (Zhang et al., 2023). In Dark Souls III, combat is decomposed into a directed skill graph of five reusable modules—camera control, target lock-on, movement, dodging, and heal-attack decision—with curriculum order

$K$6

A competitive Phase 1 agent is obtained with about 230k interaction steps; under the Phase 1 to Phase 2 shift, zero-shot transfer reaches $K$7 win rate for mid-range starts, and selective fine-tuning of only $K$8 and $K$9 raises that to $0.599$0, while the single end-to-end agent remains at $0.599$1 (Najar, 25 Jan 2026).

SkillSynth adds a further interpretation: the skill graph can be over scenarios rather than over skills. It constructs a directed multigraph $0.599$2 where nodes are scenarios and edges are skills, then samples monotone paths as abstractions of terminal workflows. The resulting graph contains 82,073 scenarios, 57,214 filtered skills, and 185,529 LLM-verified bridges; graph-guided task synthesis yields $0.599$3 higher unique scenario-skill coverage than single-skill baselines and $0.599$4 higher than random multi-skill composition (Fan et al., 28 Apr 2026).

6. Labor-market, HR, and rating applications

Outside agent execution and robotics, skill graphs often become knowledge graphs or relational statistical models used for matching, characterization, or rating.

The occupation–skill knowledge graph literature uses a heterogeneous graph over ISCO occupations and ESCO skills, enriched with Dutch vacancy data from 600,000 job postings. After matching extracted skill mentions to ESCO skills with character $0.599$5-gram Jaccard similarity and threshold $0.599$6, the final graph contains 1,220 nodes, 3,910 edges, and average degree 6.4. On balanced link prediction, Preferential Attachment obtains positive-class precision $0.599$7, recall $0.599$8, and F1 $0.599$9, while Node2Vec attains precision $0.705$0, recall $0.705$1, and F1 $0.705$2; as the negative-to-positive ratio increases, Node2Vec eventually outperforms PA in the more deployment-like imbalanced regime (Groot et al., 2021).

That same graph supports other operations. Occupation similarity is computed from Jaccard distance over skill neighborhoods, and Dijkstra search over an occupation graph with threshold $0.705$3 is used for career pathfinding. A TF-IDF-style weighting scheme identifies distinctive skills of occupation groups, using skills as terms and ISCO groups as documents (Groot et al., 2021). The HR distillation paper uses a simpler but operationally important bipartite skill-occupation graph as structured context for GPT-4-based data generation. It samples coherent subgraphs and turns them into prompts for generating job descriptions, matched resumes, and unmatched resumes, producing the RJDB benchmark with 52,000 triples and document statistics of 181.1 average words for job descriptions, 101.9 for matched resumes, and 87.1 for unmatched resumes (Pezeshkpour et al., 2023).

The competitive-games literature uses the phrase differently again. GElo constructs a skill-gap graph over players, learns embeddings by weighted random walks with 16 walks per node, walk length 100, context size $0.705$4, and embedding dimension $0.705$5, and then post-adjusts Elo ratings for active players by similarity to the top active player. Across five datasets, GElo lowers prediction error relative to vanilla Elo on four of them: for example, SC2 goes from $0.705$6 to $0.705$7, ATP from $0.705$8 to $0.705$9, and CS_2 from $53.3\%$0 to $53.3\%$1, while LOL shows no significant gain (Wang, 2023).

These papers show that in non-agentic settings the graph often functions less as an execution plan and more as a structured latent relation space for inference, ranking, or decision support.

7. Recurring limitations, unresolved semantics, and open directions

Despite the breadth of the literature, several recurring limitations remain. The first is semantic fragmentation: “skill graph” denotes very different objects in different subfields, from DAG-shaped execution plans to undirected player graphs to occupation–skill KGs. A plausible implication is that methodological transfer across papers requires close attention to node ontology and edge semantics rather than reliance on the shared name alone.

The second is partial formalization. AIP explicitly says it is “closer to a specification than a protocol”: the YAML graph is loaded into context, but an external runtime does not yet enforce traversal, scheduling, or correctness of control transfer (Blumenfeld et al., 3 Jun 2026). GraSP gives stronger execution semantics but is limited by its DAG assumption and therefore does not naturally represent cyclic or iterative tasks without unrolling or future loop constructs (Xia et al., 20 Apr 2026). GeoSkill defines graph objects and evolution operators but leaves retrieval fusion, merge thresholds, prune thresholds, and path search under-specified (Yang et al., 10 Apr 2026). ASG-SI proposes an audited directed multigraph and runnable prototype, but it offers an evaluation plan rather than benchmark tables (Huang et al., 28 Dec 2025).

A third limitation is graph quality dependence on upstream metadata or curation. GoS explicitly depends on parser-first normalization, I/O compatibility, and sparse relation induction from skill packages, and the paper notes that poor documentation can degrade edge quality (Liu et al., 7 Apr 2026). GoSkills assumes visible requirements are known before execution and does not model hidden evaluator requirements or runtime execution repair (Zeng et al., 7 May 2026). SkillDAG admits that online edits are accepted after single observations under structural invariants rather than statistical confidence thresholds, leaving long-run reliability of graph evolution open (Bai et al., 2 Jun 2026).

A fourth concern is coverage and bias. Labor-market graphs are conditioned by the posting sample, the Dutch market, and a simple string-matching entity linker, so only a subset of ESCO and ISCO appears in the final graph (Groot et al., 2021). The HR benchmark graph is partly extended by GPT-4 and remains a single-relation occupation–skill graph rather than a richer ontology (Pezeshkpour et al., 2023). RSG currently depends on human-provided task and environment queries because exteroceptive sensing is not integrated into the graph loop (Zhang et al., 2023).

Finally, several papers point toward graph-based learning over skills as future work. AIP argues that its bounded, typed, schema-validated graph provides a natural action space for reinforcement learning over skill edits (Blumenfeld et al., 3 Jun 2026). Robotic assembly proposes failure-probability-aware planning, contextual selection among multiple skill implementations, and foundation-model-assisted failure discovery as natural extensions of the same graph abstraction (Yu et al., 13 Mar 2026). SkillGraph and SkillDAG already move in this direction by updating graph structure during deployment, but both leave open how to control graph growth, prevent spurious relations, and maintain consistency at scale (Nie et al., 19 Apr 2026, Bai et al., 2 Jun 2026).

Taken together, the literature suggests a stable high-level conclusion: a skill graph is valuable when it turns skill use from an unstructured prompt or flat library lookup into an explicit relational object. What remains unsettled is which relations should be first-class, how much of execution should be enforced by runtime rather than inferred by the model, and how graph evolution can be made both data-efficient and trustworthy.