One goal in.
A verified result out.

A skill that runs a fleet of sub-agents across your codebase and does not stop until the work is proven.

Install GitHub

ingest

Ingest the world this code lives in

Prior learnings for this repo, then live state from every connected tool: schema, advisors, deploys, logs, the thread where it was reported.

map

Map the territory before touching it

One agent per area writes a structured map. A synthesis agent ranks the problems and returns the dependency graph of the work.

diagnose

Find the cause, then try to break it

An investigator returns the exact failing path. A separate agent gets that conclusion as a hypothesis to disprove.

debate

Argue about the fix before writing it

Two independent critics look for the smaller fix, the sibling caller it breaks, the symptom it only papers over.

fix

Fix in parallel, isolated

Each unit runs in its own git worktree and branch. The smallest change that actually holds, with a runnable check behind it.

review

Review the diff, not the status line

A reviewer that did not write the code reads the diff for correctness, root cause versus symptom, and broken siblings.

verify

Prove it, then go looking again

Fresh build, tests, types, lint. Then new agents sweep for what the fixes exposed. Anything found reopens diagnosis.

ship

Check the world moved, then ship

Diff against latest main, compare against every open PR for collisions, run the safety scan, open the pull request with the evidence.

It leaves when a verification pass is all green and a fresh sweep finds nothing, in the same round.

ingest

The strongest thing you can do is give an agent a way to review its work.

That is what swarm is.

Two things kill a long autonomous run.
Both are designed out.

The orchestrator holds paths, not payloads

Sub-agents do the reading and hand back a finding plus a path to the evidence. Bulk never crosses back.

Sample recon round. What crosses back: three lines and a file path.

No claim survives on one agent's word

Every root cause, fix and assumption goes to a second agent with fresh context, framed as something to disprove.

Built for runs that last hours.

Isolated while working. Stacked when shipping.

Concurrent fixers never share a working tree. Ordered chains open as a stack, so every pull request shows only its own change.

Standing safety orders

Never force-push, never push to main, never merge
No destructive shell without a human gate
No secrets in commits, logs or returns
Anything that could cost money stops and asks

Survives compaction

Durable state at the repo root, so a restart resumes instead of redoing finished work.

ledger.md
learnings.md
events.jsonl

Right model, right job

Mechanical lookups: cheapest tier
Implementation: fast tier
Design, review, verification: highest thinking

Install

Clone it into your skills directory.

Cursor or Claude Code

# clone once, symlink to both hosts
git clone https://github.com/SaarthurR/swarm.git ~/skills/swarm
ln -s ~/skills/swarm ~/.cursor/skills/swarm
ln -s ~/skills/swarm ~/.claude/skills/swarm

Then hand over the goal:

swarm, checkout drops orders under load. Find out why and fix it properly.
swarm this repo: make it production ready before Friday.
swarm, audit the auth layer. Use the Supabase MCP for schema and advisors.

One goal in.A verified result out.

Two things kill a long autonomous run. Both are designed out.