Skill Graph

Guide

100% local

Loading the graph studio

The next version of skill files

Skill files that tell an agent how to split the work

A normal SKILL.md is one block of instructions. The agent reads it top to bottom and improvises the rest: how to divide the task, what each helper should see, and when the result is good enough. On larger tasks that is where things go wrong. Helpers inherit noise, checks get skipped, and the whole skill sits in the context window from the first message.

A graph skill writes those decisions down. You draw the steps and what flows between them; the studio checks the graph and compiles it into an orchestrating skill and one subagent per step, ready for Claude Code and Cursor.

What a graph skill adds to SKILL.md

Stages
Steps that do not depend on each other run in parallel; the rest wait for exactly the inputs they need.
Contracts
Every edge names what must travel on it, so the agent can check each handoff before moving on.
Fresh context
A step can be sealed off: its subagent sees only its incoming payloads, never another step's reasoning.
Checks and approvals
A command such as npm test can fail a step, a verifier sends back only what failed, and work that is hard to undo waits for your approval.
Least privilege
Each step lists the tools and model tier it needs, which compile into its subagent's settings.
Load on demand
The agent reads a short plan when the skill triggers and each step's prompt only when that step runs.

What the agent does with it

  1. 1Your request matches the skill's description, and the agent loads the plan: a few hundred tokens, not every prompt.
  2. 2It starts the subagents of stage 1, handing each one exactly the input listed for it.
  3. 3Before the next stage, it checks each output against its contract and re-runs a step once if it does not match.
  4. 4Steps in the same stage start together. A fresh-context verifier gets only the raw outputs it audits.
  5. 5Command checks and the verifier's gate decide what passes. On a failure the agent re-runs only the steps that failed, with the reason, or stops and reports, as the plan says.
  6. 6The last step's output is returned as the answer.

The format

graph.skill.md
---
name: parallel-system-audit
description: Splits a goal into 4 parallel workers, verifies with fresh context, and synthesizes.
spec: skill-graph/1
topology:
  nodes:
    - id: worker_research
      type: worker
      model: haiku
      tools: [Read, Grep, Glob, WebSearch]
    - id: verifier
      type: verifier
      isolated_context: true
      model: opus
      tools: [Read, Grep, Glob]
      gate: Every kept claim cites concrete evidence.
      on_fail: retry
  edges:
    - from: worker_research
      to: verifier
      contract: findings_array
contracts:
  findings_array:
    format: markdown
    description: Numbered findings, each with evidence and a confidence.
---

## @node: worker_research
Focus ONLY on deep research for: {{splitter.worker_research}}

Prompts reference upstream work with {{goal}}, {{node.field}} (one key of a JSON output), {{node.output}} and group aliases such as {{workers.output}}. The studio checks that every reference points upstream, every contract is defined and the graph has no cycles, and shows exactly what each step's subagent will receive.

What you export

skill-kit.zip
.claude/skills/parallel-system-audit/SKILL.md      the plan the agent follows
.claude/skills/parallel-system-audit/graph.skill.md the editable graph
.claude/agents/parallel-system-audit-verifier.md    one subagent per step
.cursor/rules/parallel-system-audit.mdc             the same skill for Cursor

Nothing on this page calls a model or needs an API key. Your agent runs the files with its own subagents.

Questions

What is a graph skill?
A SKILL.md whose frontmatter also describes how the work is split: the steps (nodes), what each step hands the next (edges with named contracts), which steps must start with a fresh context, which tools and model tier each step gets, and pass/fail gates. The body keeps one prompt per step. It is still plain Markdown, so it lives in your repository next to your other skills.
How does it help an AI agent?
Instead of improvising how to split a task, the agent follows an explicit plan: it starts the steps of each stage in parallel as subagents, hands each one only its own input, checks every handoff against its contract, and re-runs or stops when a verifier's gate fails. It also loads less up front: the plan is small, and each step's prompt is only read when that step runs, in its own context window.
Does this page call an AI model?
No. There is no API key and no model call here. The studio parses, checks and lays out the graph in your browser and compiles it into files. The agent you already use (Claude Code, Cursor and others) runs those files with its own subagents.
What do I get when I export?
A ZIP with an orchestrating skill under .claude/skills/<name>/, one Claude Code subagent per model step under .claude/agents/ (with its tools and model; checks, gates and approvals are run by the orchestrating skill), a Cursor rule under .cursor/rules/, the editable graph source, and a README. There is also a single self-orchestrating SKILL.md for agents without subagents.
What does the prior-context bias badge mean?
On a step marked isolated_context, it is the share of the upstream material its prompt reads that does not arrive through its own incoming edges. 0% means its subagent sees only what its edges carry, which is what a verifier needs to judge the work without inheriting the workers' reasoning.
Read the full Skill Graph guide Generate CLAUDE.md, Cursor rules and single-file skills in AI Skill Studio