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.
- 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
- 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
- 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.
- .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/mcpStudying? 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 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.
- 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
Start from a working graph
10 starter graphs for code and for everything else. Open one, change what you need, and export.
- Parallel auditResearch, compare, check and find gaps, then verify in a fresh context
- Ship a changeEdit until tests pass, review the diff in parallel, approve once before the PR
- Review each fileOne fresh-context review per changed file, however many there are, then merge and gate
- PR reviewSecurity, performance, architecture and test coverage reviewers
- RFC discoveryFeasibility, prior art, interface design and failure modes
- Bug triageStack trace, logs, recent commits and a minimal repro
- Research reportSources, figures, counterpoints and open questions, fact-checked in a fresh context
- Write an articleAngle, outline, facts and reader in parallel, then an editor check before the draft
- Analyze a datasetProfile, clean, analyze and sanity-check a table in parallel, then re-check every figure
- Design an appUsers, features, screens and data model in parallel, then a product review before the spec
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
- 01Your request matches the skill's description, and the agent loads the plan: a few hundred tokens, not every prompt.
- 02It starts the subagents of stage 1, handing each one exactly the input listed for it.
- 03Before the next stage, it checks each output against its contract and re-runs a step once if it does not match.
- 04Steps in the same stage start together. A fresh-context verifier gets only the raw outputs it audits.
- 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.
- 06The last step's output is returned as the answer.
The format
---
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.
Write your next skill as a graph.
Building bigger workflows, with loops and lessons? Skill Graph Pro, $19 a year