Multi-agent skills, designed as a graph.

Draw the steps, what each one hands the next and the checks between them. Skill Graph checks the plan and compiles it into a Claude Code skill with one subagent per step, or a Cursor rule.

Free for small workflows and every blueprint; Pro is $19 a year. Runs in your browser, and nothing you write is uploaded. No API key, no account.

From a sketch to files your agent runs

A normal SKILL.md leaves the agent to improvise how to split the work. A graph skill writes it down, and Skill Graph turns it into something the agent can follow.

  1. 01

    Design

    Lay out the steps on a canvas, or write them in Markdown; both stay in sync. Each edge names what it carries, and a verifier can start in a fresh context.

    graph.skill.md

  2. 02

    Check

    The checker flags cycles, missing contracts, inputs that never arrive and vague gates. Walk through the plan stage by stage and see what every subagent receives.

    issues · plan · dry run

  3. 03

    Compile

    Export an orchestrating SKILL.md with one Claude Code subagent per step, each with its own tools and model, plus the same skill as a Cursor rule.

    .claude/ · .cursor/

A kit you drop into your repository

One orchestrating skill, one subagent per step and a Cursor rule. Your agent runs it with its own subagents; nothing here calls a model.

  • Steps that do not depend on each other run in parallel.
  • Each subagent gets only its own input, never the others' reasoning.
  • Every handoff is checked against its contract before the next stage.
  • A fresh-context verifier gates the result and re-runs only what failed.
parallel-system-audit-skill-kit.zip12 files
  • .claude/skills/parallel-system-audit/SKILL.mdorchestrator
  • .claude/skills/parallel-system-audit/graph.skill.mdgraph source
  • .claude/agents/parallel-system-audit-splitter.mdsubagent
  • .claude/agents/parallel-system-audit-worker-research.mdsubagent
  • .claude/agents/parallel-system-audit-worker-compare.mdsubagent
  • .claude/agents/parallel-system-audit-worker-check.mdsubagent
  • .skill-graph/.gitignoresupport
  • .cursor/rules/parallel-system-audit.mdcCursor rule
  • README.mdreadme
  • + 3 more subagents

Or describe it, and let Claude build it

Add Skill Graph to Claude as a connector. Claude drafts the workflow, checks it until it has no errors and hands you a studio link and the kit. No account and no API key.

Connector URL

https://www.devscratchpad.tech/graph/mcp
Set it up in Claude or Claude Code

Studying? My Level is a separate, lighter connector for students: Claude explains things at your level, checked in code, and quizzes you before you forget.

Claude Code

$ claude mcp add --transport http skill-graph https://www.devscratchpad.tech/graph/mcp

> Design a workflow that reviews my pull requests: security, performance and tests in parallel, then a fresh-context check before it comments.

draft_graph
pr-review-graph · 7 steps in 4 stages
validate_graph
0 errors
compile_graph
12 files

Open pr-review-graph in Skill Graph · Download the kit

A model we trained to read your gates

A gate like "the work is thorough" lets a checker pass anything. With Skill Graph Pro, when Claude checks a graph through the connector, a small classifier we fine-tuned reads each gate against what its step receives, and warns when no checker could decide it.

  • On gates written by hand that it never saw in training: 20 of 21 vague ones flagged, none of 42 checkable ones.
  • A MiniLM cross-encoder of 33 million parameters, fine-tuned by us, compressed to a 34 MB file.
  • About 70 milliseconds per gate, in memory on our server. Nothing is stored or sent elsewhere.
How the gate check works
sg-sem-h4-1warns at 0.89
  • No blocking finding is left open, and every finding cites a line of the diff.0.02 ok
  • All tests pass.0.01 ok
  • Every finding names a file and line that exist.0.01 ok
  • The user will be happy with the result and find it useful.0.92 warns
  • The work is thorough, accurate and professional.0.92 warns
  • The fixes are elegant.0.91 warns

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. 01Your request matches the skill's description, and the agent loads the plan: a few hundred tokens, not every prompt.
  2. 02It starts the subagents of stage 1, handing each one exactly the input listed for it.
  3. 03Before the next stage, it checks each output against its contract and re-runs a step once if it does not match.
  4. 04Steps in the same stage start together. A fresh-context verifier gets only the raw outputs it audits.
  5. 05Command 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. 06The 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.

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.
Generate CLAUDE.md, Cursor rules and single-file skills in AI Skill Studio

Write your next skill as a graph.

Building bigger workflows, with loops and lessons? Skill Graph Pro, $19 a year