Agent orchestration for Claude Code
swarmdo turns Claude Code into a coordinated multi-agent system — 60+ agent roles, hive-mind consensus, persistent vector memory, and a Postgres vector extension. Fully self-contained: every engine ships in the repo. Based on the original ruflo.
A real swarmdo pipeline: five named agents, coordinated over messages, sharing one memory.
The projects
Three separate projects, not one product in three parts: the orchestration plugin you run in Claude Code, the open coding models, and a general-purpose GPU marketplace. They complement each other, but each stands alone — and each has its own home.
the plugin & MCP server
Turns Claude Code into a coordinated multi-agent system — 60+ agent roles, hive-mind consensus, persistent vector memory, and self-learning hooks. MIT, fully self-contained.
open coding agents
Open, self-hostable LLMs for agentic software engineering. A1 is the coding tier; A2 carries code and vision in one checkpoint. Every gain proven by running the project’s own tests.
rent GPUs by the second
A spot GPU marketplace — H100s down to RTX 3090s, aggregated into one catalog and one bill. Per-second billing, one-click SSH and Jupyter, a hard spend cap per instance. Any workload; not tied to SwarmDo.
What it does
swarmdo registers as an MCP server and wires agents, memory, and consensus into every session — with hooks that learn from what worked.
Hierarchical, mesh, ring, star, or hybrid topologies with anti-drift defaults. Named agents coordinate over real-time messages — pipelines, fan-out, supervisor patterns.
Queen-led coordination with raft, byzantine, gossip, CRDT, or quorum strategies. Byzantine mode tolerates f < n/3 faulty agents.
AgentDB-backed persistent memory with HNSW indexing — semantic search across sessions, namespaces shared by every agent in the swarm.
A pgvector-compatible extension with 230+ SQL functions, SIMD, and quantization. CREATE EXTENSION swarmvector — verified on PostgreSQL 16.
27 lifecycle hooks and 12 background workers record what succeeded, train routing patterns, and preload context before you ask.
Why use many token when few token do trick. /sdo-caveman-compress rewrites memory files into few-token caveman-speak — substance, code, and URLs preserved, backup kept. Vendored from the 82k-star original (MIT).
The laziest senior dev in the room, on demand. /sdo-ponytail forces the simplest solution that works: YAGNI, stdlib before dependencies, one line before fifty. Three intensities + audit and review lenses (MIT).
Twelve segments, three presets, one checklist. Run /sDo:statusline inside Claude Code and tick exactly what you want to see.
One word for how much swarmdo you want: ultra 🦾, smart 🧠 (recommended), light 🪶, or minimal 🔩. One dial moves the session levers, the local model, the efficiency skills, and the base preset together — and writes a .swarmdo/profile.env so Codex/Copilot/pi share the mode. A brand-new session with none set is prompted to pick one. Try the chooser →
Every swarmdo slash command groups under /sDo: (skills /sdo-). Type /sDo in Claude Code and the whole toolkit surfaces together — legacy unprefixed copies auto-migrate on init.
One word of setup
Profiles are a single dial over the whole toolkit — session levers, the local model, the efficiency skills, and the base preset all move together. A brand-new session with none set asks you to pick one. Try the ladder here:
When to use
swarmdo profile list
The models · A2 now out
swarmdo isn't only orchestration. SwarmDo-A1 and SwarmDo-A2 are our open, self-hostable coding models — a strong open base rebuilt for agentic software engineering, where every gain is proven by running the project's own tests, plus a differentiated visual-coding capability. They ship in parallel with the plugin, and — like everything here — they're measured honestly, negatives included.
The single biggest measured win was re-basing onto a stronger open model (Qwen3.6-27B). On a contamination-controlled held-out set that beat the prior base by ≈25 points — paired McNemar p = 0.013. Capability dominates cleverness.
The system samples several candidate patches and keeps the ones that pass. Base + execution-verified selection solved 50% more issues than the base alone — p = 0.0005, regression-free. No LLM-as-judge.
Show it a chart; it writes the code to reproduce it; we render that code and compare to the image — an objective reward you can't bluff. The image genuinely drives the output (p = 6e-05), and the model self-generates its own render-verified training data.
Apache-2.0, fits a single 80GB GPU, no API lock-in. Multimodal (text + vision). Serves through vLLM as an OpenAI-compatible endpoint; on-device paths via MLX / GGUF / GPTQ-Int4.
Single-model fine-tuning alone gave no significant gain (a "churn wall") — which is exactly why A1 is a system, not a magic checkpoint. We publish the null results too. No number is rounded up.
The adapter is on Hugging Face now (LoRA on Qwen3.6-27B); the full model card, reproduce guides, and results live in the models repo.
SwarmDo-A2 folds A1's coding delta and a separately trained visual-coding delta into a single rank-48 adapter on the same base. Combining them degraded neither half — the visual moat held (Δ −0.006, not worse) and coding held (18 vs 19 solved, p = 1.0). See both models →
Operator tools
The v1.3–v1.5 train added a day-to-day operations layer around the swarm — spend, safety, releases, model routing, and memory portability. No plugins required.
swarmdo usage reads your local Claude Code transcripts: daily/monthly/model/project views, live 5-hour block burn, tool-failure analytics, interruption + error-category friction, prompt-cache efficiency with dollars saved, and period-over-period diffs with per-model movers.
usage guard --block-usd 5 --strict turns limits for the active 5h block, today, or the month into ok/warn/over — exit 1 when over, safe for CI gates and Stop hooks.
swarmdo hud --watch is one screen for the whole install: block burn, task readiness, daemon workers, memory snapshots.
swarmdo repair runs a bounded, budget-capped headless claude loop that edits source until a failing test passes. Dry-run unless you --confirm.
swarmdo wt gives parallel agents their own git worktrees — add, list, diff, merge, remove — so concurrent edits never collide.
swarmdo changelog --out NOTES.md groups your conventional commits into linked release notes, ready for gh release create.
swarmdo hooks recipe notify-done --apply installs “ping me when Claude finishes” as a real Stop hook — idempotent, dry-run by default, never clobbers your settings — or command-guard to block dangerous bash (rm -rf /, pipe-to-shell, force-push to main) via a PreToolUse deny hook. Desktop toasts via hooks notify -d.
memory export -f obsidian renders the vector DB as a markdown vault — frontmatter, live [[wikilinks]] — edit in Obsidian, then memory import -f obsidian syncs it back, re-embedded — add --watch and it stays live-synced while you type.
init --preset basic — five named tiers from minimal to max instead of dozens of flags. swarmdo preset info explains every rung.
Declare tier-mapped OpenRouter models in swarmdo.config.json and swarms pick per task — the router Thompson-samples among your candidates and dispatches the winner. config lint validates the section with the same parser the runtime uses.
Run Claude Code itself on your pool: swarmdo route serve starts a local Anthropic-compatible proxy and ANTHROPIC_BASE_URL points Claude Code at your OpenRouter models — full SSE streaming, tier routing, and per-model learned priors shared with your swarms' routing, so both learn from each other. No vendored proxy, no extra process.
One command each: swarmdo obsidian on|off turns the dual-plane Obsidian memory vault (edit in Obsidian, sync back re-embedded) on/off, and swarmdo llm on|off toggles the local SwarmLLM backend — showing a 🧬 LLM statusline icon while on. Or the /sDo:obsidian and /sDo:llm slash commands.
Opt-in swarmdo memory search --rerank (composes with --smart) reranks the retrieved pool with a cross-encoder — ADR-083's strongest relevance signal — for the best top-k, lazy-loading a ~30MB model and falling back to pre-rerank order if it's unavailable, so a search never breaks. Also rerank on the memory_search MCP tool.
swarmdo memory distill turns a raw session transcript into dense atomic facts — opt-in, dry-run by default, one budget-capped claude call — stored in the distilled namespace and retrievable through memory search. The first tier (L1) of a Tencent-style distillation pyramid; measure the payoff with swarmdo usage.
swarmdo integrations wires swarmdo into Codex CLI, GitHub Copilot CLI, and pi — AGENTS.md plus each CLI’s MCP config, idempotent merges, and your Claude Code setup is never touched. Once wired, the same mailbox, git-analysis, and memory tools work from those CLIs too. And integrations skills deploys ~20 curated skills (the cross-agent SKILL.md standard) to the shared ~/.agents/skills plus Codex and pi, so swarmdo’s playbooks auto-activate there — not just its tools.
swarmdo tx export turns any Claude Code session into clean shareable markdown; tx search full-text-searches every session you’ve ever run.
Tasks carry real dependencies: task ready lists unblocked work, task graph renders the graph, and task parse-prd spec.md decomposes a spec straight into the DAG.
swarmdo testreport parses JUnit/TAP results into the exact failing tests + file:line + assertion message — the front-half of the test→fix loop, feeding straight into repair. Reads a file, dir, or stdin; --ci gates a build. Also an MCP tool.
swarmdo cycles scans the import graph for circular dependencies — the mutually-importing modules that cause temporal-dead-zone and undefined-export bugs (madge --circular style). Provably correct via Tarjan SCC; --ci gates a build. Also an MCP tool.
swarmdo affected walks the import graph from your git diff to list every file — and the minimal set of test files — a change could break, so you run only the tests your change touches (nx/turbo/jest --findRelatedTests style). Pipeable; also an MCP tool.
swarmdo hotspots ranks files by change-risk mined from git history — churn × recency × author-spread — so you (or an agent) can find the technical debt worth refactoring or testing, from data instead of a guess. Pairs with codegraph; also an MCP tool.
swarmdo apply is a forgiving git apply — it lands an agent’s unified diff even when the context lines have drifted, and reports exactly which hunks it couldn’t place instead of rejecting the whole patch. Also an MCP tool.
swarmdo sbom emits a CycloneDX or SPDX bill-of-materials from your lockfile — every dependency with version, package-url, license, and integrity hash, for compliance and vuln tooling. Deterministic (no timestamp), so it diffs cleanly in CI.
swarmdo license walks node_modules, resolves each dependency's SPDX license, and gates on an allow/deny policy — so a GPL or unknown license can't slip into a permissive tree. --ci fails the build; also an MCP tool. Deterministic.
swarmdo env scans your code for env-var references and reconciles them against .env / .env.example — flagging vars that are missing, unused, or undocumented before a deploy breaks. --ci fails the build; also an MCP tool. Deterministic.
swarmdo pack bundles a repo into one AI-friendly blob — markdown, XML, JSON, or plain, with a directory tree, per-file token counts, .gitignore-aware walking, and glob include/exclude. --tokens for a budget breakdown, --redact to strip secrets first. Deterministic.
swarmdo redact masks API keys, tokens, and private keys before they reach an LLM, a log, or memory — a gitleaks-style rule catalog plus an entropy fallback, as a stdin filter, a command wrapper, or a --scan CI gate — --scan --sarif emits a SARIF 2.1.0 report so leaked secrets surface as GitHub code-scanning alerts. Deterministic, zero tokens; also exposed as MCP tools so agents self-censor.
swarmdo codegraph index maps every exported symbol in your TS/JS (1,750 across 289 files in under a second), then codegraph query buildIndex or codegraph file src/index.ts answers “where is this defined / what does this file export” from disk — no grep+read round-trips. It also maps the import graph, so codegraph importers answers “what breaks if I change this file.” Exposed as MCP tools too, so agents query it in-session.
npm test 2>&1 | swarmdo compact strips ANSI, collapses repeated lines, folds node_modules stack frames, and windows long logs — noisy command output shrinks before it burns an agent’s context. Deterministic, zero tokens; -- npm test to wrap a command (exit code propagates).
swarmdo mcp doctor statically validates every configured MCP server across .mcp.json and ~/.claude.json — missing binaries, bad URLs, malformed entries — without spawning anything.
swarmdo comms lets one agent session — Claude Code, Codex, Copilot, or pi — message another by name: send, inbox, read, watch, and -t all to broadcast. Sessions on the same repo share a mailbox; a hook surfaces new mail as prompt context without polling. Also MCP tools.
swarmdo hooks memory-inject embeds each prompt, vector-searches your stored memories, and injects the most relevant ones under a token budget — recall at the moment of need instead of a manual search. One command wires it as a UserPromptSubmit hook.
swarmdo permissions statically audits your Claude Code permission rules — allow↔deny conflicts (dead rules), over-broad Bash(*) grants, shadowed and duplicate rules, malformed entries. --strict gates CI. Read-only.
swarmdo coupling mines git history for the files that keep changing together — the empirical complement to affected’s static import graph, so you catch the co-edit no import edge would reveal (a schema and its type, a serializer split across modules). --file answers “what changes with X?” Modeled on code-maat; also an MCP tool.
swarmdo ownership maps who owns each file from git history — the dominant author, how concentrated the churn is, and the bus factor (a lone owner is flagged a key-person risk), plus a repo-wide truck factor. “Who should review this, and what breaks if they leave?” code-maat main-dev / CodeScene Knowledge Map; also an MCP tool.
swarmdo hidden-coupling joins the two graphs swarmdo already owns — temporal co-change from git and codegraph’s import graph — and surfaces the pairs that change together yet no import edge links (logical minus structural coupling): a config and its consumers, a schema and its mirror type. The co-edit affected can’t see. Grounded in Gall et al. (ICSM 1998).
swarmdo standup answers “what did I do?” from git history — your commits since your last working day, grouped by day with a diffstat. Weekend-aware (git-standup parity): on Monday it reaches back to Friday, not just yesterday. One-command recall for a standup or for re-orienting at the start of a session; --all/--author for teammates, --format json for tooling.
swarmdo agent bridge links Claude Code’s Agent-tool agents into Swarmdo’s registry — the fix for “Swarmdo is installed but agent list is always empty while real agents run.” bridge register binds a running agent and auto-spins-up a swarm from your config, enrolling it; the next bind joins the same swarm. Automatic since 1.58.18: a SubagentStart hook registers every Claude Code subagent as it spawns and SubagentStop retires it, so 🐝 Swarms N · 🤖 Agents M tracks real agents with no manual step. bridge sync reconciles drift, bridge advise says whether a prompt warrants a swarm. Also MCP tools.
swarmdo task doctor tells a transient wait from a permanent stall — a task whose prerequisite failed, was cancelled, or is missing will never run — and flags whole-graph deadlock, so a dispatch loop can’t spin forever. --ci gates it (Airflow upstream_failed semantics).
swarmdo config lint statically validates swarmdo.config.json, the settings hooks block, .mcp.json, your .claude/agents/*.md subagents (a missing name/description, a name duplicated across files — Claude Code silently loads only one — a bad model, malformed frontmatter), and your custom slash commands + skills (malformed YAML that makes CC load empty metadata, a bad effort, an inline !`cmd` bash-injection that’s inert or not covered by allowed-tools). --strict gates CI.
swarmdo commands is the dead-code report for your authored .claude/ surface — which custom slash-commands and subagents you actually invoke (hot), which are defined but never used (cold, prune candidates), and which are invoked but undefined (orphan — typo or builtin). Joins your defined files against invocation counts mined from local transcripts. Where config lint asks “are these valid?”, this asks “are these used?” --unused --strict gates CI; --json for tooling.
Honest numbers
Benchmarks live in the repo and every claim is labeled. No mystery multipliers.
Efficiency
Two of the most-loved Claude Code skills ship inside swarmdo as first-class features — vendored MIT forks, integrated into the CLI, the agents, and the init wizard. Toggle them per project with swarmdo efficiency on|off.
Memory files (CLAUDE.md, notes, todos) get re-read every session — and they're written for humans, not token budgets. /sdo-caveman-compress rewrites them in few-token caveman-speak: substance, code, and URLs preserved, original backed up.
Also a CLI command — works outside Claude Code entirely:swarmdo compress CLAUDE.md · --check for a token-free dry run.
The laziest senior dev in the room, on demand. /sdo-ponytail applies one lens to everything: the best code is the code never written.
Three intensities (lite · full · ultra) plus audit, review, and debt lenses. And it reaches the swarm too: pass ponytail: true when spawning an agent — or set SWARMDO_PONYTAIL=1 — and every spawned agent inherits the persona.
Explicit ponytail: false always wins over the env. Skills are user-invoked: on means available, never automatic.
Vendored with attribution from the MIT originals: caveman by Julius Brussee and ponytail by Dietrich Gebert — see NOTICE.
Self-contained
No runtime downloads from third-party registries, no surprise upstream churn. Each engine is vendored, renamed, smoke-tested, and file-linked.
| Engine | What it is | Form |
|---|---|---|
| swarmvector | Vector database — HNSW, ONNX embeddings (384-dim), Graph RAG | native + wasm |
| swarmvector-postgres | Postgres extension, pgvector drop-in, pg 14–17 | pgrx crate |
| swarmllm | Local model layer — MicroLoRA adapters, SONA learning | native + wasm |
| swarmdo-swarm | Swarm MCP server — cognitive patterns, neural agents | node + wasm |
| agentdb | Agent memory store — vectors, reinforcement learning | vendored |
| agentic-flow | Agent runtime integration and ONNX embedding backend | vendored |
| @swarmnet/bmssp | Graph pathfinding for agent topology routing | wasm |
Install
Scaffolds .claude/ with agents, skills, hooks, and the /sDo:statusline command.
Registers the MCP server — 200+ tools for agents, memory, and coordination.
Claude Code spawns the agents; swarmdo coordinates, remembers, and learns.
Reference
146 /sDo: slash commands (in .claude/commands/sDo/) plus 38 /sdo- skills. Type /sDo: in Claude Code to browse; most wrap a npx swarmdo call or an MCP tool, so they also work from Codex, Copilot & pi via MCP + AGENTS.md. Full detail lives in the USERGUIDE.
/sDo:sparc | Execute SPARC methodology workflows with Swarmdo |
/sDo:statusline | Edit the swarmdo statusline — pick segments via checklist or preset |
/sDo:swarmdo-help | Show Swarmdo commands and usage |
/sDo:swarmdo-memory | Interact with Swarmdo memory system |
/sDo:swarmdo-swarm | Coordinate multi-agent swarms for complex tasks |
/sDo:coordination/agent-spawn | Spawn a new agent in the current swarm. |
/sDo:coordination/init | Initialize swarm coordination for the current task (wraps mcp swarm_init). |
/sDo:coordination/orchestrate | Orchestrate a task across the swarm (wraps mcp task_orchestrate). |
/sDo:coordination/spawn | Spawn an agent into the current swarm (wraps mcp agent_spawn). |
/sDo:coordination/swarm-init | Initialize a Swarmdo swarm with specified topology and configuration. |
/sDo:coordination/task-orchestrate | Orchestrate complex tasks across the swarm. |
/sDo:swarm/analysis | Comprehensive analysis through distributed agent coordination. |
/sDo:swarm/development | Coordinated development through specialized agent teams. |
/sDo:swarm/examples | Worked examples and recipes for swarm invocations. |
/sDo:swarm/maintenance | System maintenance and updates through coordinated agents. |
/sDo:swarm/optimization | Performance optimization through specialized analysis. |
/sDo:swarm/research | Deep research through parallel information gathering. |
/sDo:swarm/swarm | Main swarm orchestration command for Swarmdo. |
/sDo:swarm/swarm-analysis | Analyze a running swarm’s operations. |
/sDo:swarm/swarm-background | Launch a swarm to run in the background. |
/sDo:swarm/swarm-init | Initialize a new swarm with specified topology. |
/sDo:swarm/swarm-modes | List the available swarm execution modes. |
/sDo:swarm/swarm-monitor | Monitor live swarm activity. |
/sDo:swarm/swarm-spawn | Spawn agents in the swarm. |
/sDo:swarm/swarm-status | Show swarm status. |
/sDo:swarm/swarm-strategies | List swarm distribution strategies. |
/sDo:swarm/testing | Comprehensive testing through distributed execution. |
/sDo:hive-mind/hive-mind | Hive Mind collective intelligence system for advanced swarm coordination. |
/sDo:hive-mind/hive-mind-consensus | Run a consensus vote across the hive mind. |
/sDo:hive-mind/hive-mind-init | Initialize the Hive Mind collective intelligence system. |
/sDo:hive-mind/hive-mind-memory | Read / write the hive-mind shared memory. |
/sDo:hive-mind/hive-mind-metrics | Show hive-mind performance metrics. |
/sDo:hive-mind/hive-mind-resume | Resume a saved hive-mind session. |
/sDo:hive-mind/hive-mind-sessions | List hive-mind sessions. |
/sDo:hive-mind/hive-mind-spawn | Spawn a Hive Mind swarm with queen-led coordination. |
/sDo:hive-mind/hive-mind-status | Show hive-mind status. |
/sDo:hive-mind/hive-mind-stop | Stop the running hive mind. |
/sDo:hive-mind/hive-mind-wizard | Interactive wizard to configure & launch a hive mind. |
/sDo:agents/agent-capabilities | Matrix of agent capabilities and their specializations. |
/sDo:agents/agent-coordination | Coordination patterns for multi-agent collaboration. |
/sDo:agents/agent-spawning | Guide to spawning agents with Claude Code's Task tool. |
/sDo:agents/agent-types | Complete guide to all 54 available agent types in Swarmdo. |
/sDo:automation/auto-agent | Automatically spawn and manage agents based on task requirements. |
/sDo:automation/self-healing | Automatically detect and recover from errors without interrupting your flow. |
/sDo:automation/session-memory | Maintain context and learnings across Claude Code sessions for continuous improvement. |
/sDo:automation/smart-agents | Automatically spawn the right agents at the right time without manual intervention. |
/sDo:automation/smart-spawn | Intelligently spawn agents based on workload analysis. |
/sDo:automation/workflow-select | Automatically select optimal workflow based on task type. |
/sDo:sparc/analyzer | Deep code and data analysis with batch processing capabilities. |
/sDo:sparc/architect | System design with Memory-based coordination for scalable architectures. |
/sDo:sparc/ask | Task-formulation guide — helps you frame and delegate work to the right mode. |
/sDo:sparc/batch-executor | Parallel task execution specialist using batch operations. |
/sDo:sparc/code | Auto-Coder — writes clean, modular code from pseudocode + architecture. |
/sDo:sparc/coder | Autonomous code generation with batch file operations. |
/sDo:sparc/debug | Debugger — traces and fixes runtime, logic, and integration bugs. |
/sDo:sparc/debugger | Systematic debugging with TodoWrite and Memory integration. |
/sDo:sparc/designer | UI/UX design with Memory coordination for consistent experiences. |
/sDo:sparc/devops | DevOps — deployment, infrastructure, CI/CD, and cloud provisioning. |
/sDo:sparc/docs-writer | Documentation Writer — concise, modular Markdown docs. |
/sDo:sparc/documenter | Documentation with batch file operations for comprehensive docs. |
/sDo:sparc/innovator | Creative problem solving with WebSearch and Memory integration. |
/sDo:sparc/integration | System Integrator — merges module outputs into a tested, working system. |
/sDo:sparc/mcp | MCP Integration — connects to and manages external MCP services. |
/sDo:sparc/memory-manager | Knowledge management with Memory tools for persistent insights. |
/sDo:sparc/optimizer | Performance optimization with systematic analysis and improvements. |
/sDo:sparc/orchestrator | Multi-agent task orchestration with TodoWrite/TodoRead/Task/Memory using MCP tools. |
/sDo:sparc/post-deployment-monitoring-mode | Deployment Monitor — watches post-launch performance, logs, and feedback. |
/sDo:sparc/refinement-optimization-mode | Optimizer — refactors, modularizes, and enforces file-size limits. |
/sDo:sparc/researcher | Deep research with parallel WebSearch/WebFetch and Memory coordination. |
/sDo:sparc/reviewer | Code review using batch file analysis for comprehensive reviews. |
/sDo:sparc/security-review | Security Reviewer — static/dynamic audits; flags secrets and weak points. |
/sDo:sparc/sparc | SPARC Orchestrator — breaks large objectives into delegated subtasks. |
/sDo:sparc/sparc-modes | Overview of all 17 SPARC specialist modes. |
/sDo:sparc/spec-pseudocode | Specification Writer — captures requirements and writes pseudocode. |
/sDo:sparc/supabase-admin | Supabase Admin — database, auth, and storage design/management. |
/sDo:sparc/swarm-coordinator | Specialized swarm management with batch coordination capabilities. |
/sDo:sparc/tdd | Test-driven development with TodoWrite planning and comprehensive testing. |
/sDo:sparc/tester | Comprehensive testing with parallel execution capabilities. |
/sDo:sparc/tutorial | SPARC Tutorial — onboarding guide to the full SPARC workflow. |
/sDo:sparc/workflow-manager | Process automation with TodoWrite planning and Task execution. |
/sDo:github/code-review | Automated code review with swarm intelligence. |
/sDo:github/code-review-swarm | Deploy specialized AI agents to perform comprehensive, intelligent code reviews that go beyond traditional static analysis. |
/sDo:github/github-modes | Reference of all GitHub integration modes (swarm-coordinated). |
/sDo:github/github-swarm | Create a specialized swarm for GitHub repository management. |
/sDo:github/issue-tracker | Intelligent issue management — tracking, triage, and progress coordination. |
/sDo:github/issue-triage | Intelligent issue classification and triage. |
/sDo:github/multi-repo-swarm | Coordinate AI swarms across multiple repositories, enabling organization-wide automation and intelligent cross-project collaboration. |
/sDo:github/pr-enhance | AI-powered pull request enhancements. |
/sDo:github/pr-manager | Comprehensive pull request management with swarmdo-swarm coordination for automated reviews, testing, and merge workflows. |
/sDo:github/project-board-sync | Synchronize AI swarms with GitHub Projects for visual task management, progress tracking, and team coordination. |
/sDo:github/release-manager | Automated release coordination: versioning, testing, and deployment. |
/sDo:github/release-swarm | Orchestrate complex software releases using AI swarms that handle everything from changelog generation to multi-platform deployment. |
/sDo:github/repo-analyze | Deep analysis of GitHub repository with AI insights. |
/sDo:github/repo-architect | Repository structure optimization and multi-repo management. |
/sDo:github/swarm-issue | Turn a GitHub issue into a coordinated AI-swarm task. |
/sDo:github/swarm-pr | Create and manage AI swarms directly from GitHub Pull Requests, enabling seamless integration with your development workflow. |
/sDo:github/sync-coordinator | Multi-package version alignment and cross-package synchronization. |
/sDo:github/workflow-automation | Generate a custom swarm-powered GitHub Actions workflow. |
/sDo:workflows/development | Structure Claude Code's approach to complex development tasks for maximum efficiency. |
/sDo:workflows/research | Coordinate Claude Code's research activities for comprehensive, systematic exploration. |
/sDo:workflows/workflow-create | Create reusable workflow templates. |
/sDo:workflows/workflow-execute | Execute saved workflows. |
/sDo:workflows/workflow-export | Export workflows for sharing. |
/sDo:memory/memory-persist | Persist memory across sessions. |
/sDo:memory/memory-search | Search through stored memory. |
/sDo:memory/memory-usage | Manage persistent memory storage. |
/sDo:memory/neural | Train / query neural coordination patterns. |
/sDo:hooks/overview | Automatically coordinate, format, and learn from Claude Code operations using hooks. |
/sDo:hooks/post-edit | Execute post-edit processing including formatting, validation, and memory updates. |
/sDo:hooks/post-task | Execute post-task cleanup, performance analysis, and memory storage. |
/sDo:hooks/pre-edit | Execute pre-edit validations and agent assignment before file modifications. |
/sDo:hooks/pre-task | Execute pre-task preparations and context loading. |
/sDo:hooks/session-end | Cleanup and persist session state before ending work. |
/sDo:hooks/setup | Install & configure Swarmdo hooks (npx swarmdo init --hooks). |
/sDo:monitoring/agent-metrics | View agent performance metrics. |
/sDo:monitoring/agents | List the active agents and their state. |
/sDo:monitoring/real-time-view | Real-time view of swarm activity. |
/sDo:monitoring/status | Show current swarm / system status. |
/sDo:monitoring/swarm-monitor | Real-time swarm monitoring. |
/sDo:analysis/bottleneck-detect | Analyze performance bottlenecks in swarm operations and suggest optimizations. |
/sDo:analysis/performance-bottlenecks | Identify and resolve performance bottlenecks in your development workflow. |
/sDo:analysis/performance-report | Generate comprehensive performance reports for swarm operations. |
/sDo:analysis/token-efficiency | Reduce token consumption while maintaining quality through intelligent coordination. |
/sDo:analysis/token-usage | Analyze token usage patterns and optimize for efficiency. |
/sDo:optimization/auto-topology | Automatically select the optimal swarm topology based on task complexity analysis. |
/sDo:optimization/cache-manage | Manage operation cache for performance. |
/sDo:optimization/parallel-execute | Execute tasks in parallel for maximum efficiency. |
/sDo:optimization/parallel-execution | Execute independent subtasks in parallel for maximum efficiency. |
/sDo:optimization/topology-optimize | Optimize swarm topology for current workload. |
/sDo:training/model-update | Update neural models with new data. |
/sDo:training/neural-patterns | Continuously improve coordination through neural network learning. |
/sDo:training/neural-train | Train neural patterns from operations. |
/sDo:training/pattern-learn | Learn patterns from successful operations. |
/sDo:training/specialization | Train agents to become experts in specific domains for better performance. |
/sDo:pair/commands | Complete reference for all pair programming session commands. |
/sDo:pair/config | Complete configuration guide for pair programming sessions. |
/sDo:pair/examples | Real-world examples and scenarios for pair programming sessions. |
/sDo:pair/modes | Detailed guide to pair programming modes and their optimal use cases. |
/sDo:pair/session | Complete guide to managing pair programming sessions. |
/sDo:pair/start | Start a new pair programming session with AI assistance. |
/sDo:stream-chain/pipeline | Execute predefined pipelines for common development workflows. |
/sDo:stream-chain/run | Execute a custom stream chain with your own prompts. |
/sDo:verify/check | Run verification checks on code, tasks, or agent outputs. |
/sDo:verify/start | Truth verification system for ensuring code quality and correctness with a 0.95 accuracy threshold. |
/sDo:truth/start | View truth scores and reliability metrics for your codebase and agent tasks. |
A header line plus optional detail rows. Configure with /sDo:statusline (checklist or preset) or .swarmdo/statusline.json. Presets: full (all 11) · compact (version, project, branch, model, context, cost, swarm) · minimal (project, branch, model, context).
version | ▊ Swarmdo Vx.y.z — installed version |
project | ● project name (cyan when a swarm is coordinating) |
branch | ⏇ git branch + change dots + ↑ahead / ↓behind |
model | active Claude model name |
duration | ⏱ session wall-clock |
context | ● N% context-window used (green→red) |
cost | Plan-aware: rate-limit % (5h 72%⚠ · 7d 12%) on subscription accounts, $N.NN on pay-as-you-go. Configure with swarmdo statusline --cost-mode. |
domains | 🏗️ DDD Domains progress bar + N/5 |
swarm | 🐝 Swarms N · 🤖 Agents M · 🪝 hooks on/total · sec · 💾 mem · 🧠 intelligence% |
architecture | 🔧 ADRs impl/total · DDD % · Security status |
agentdb | 📊 Vectors (⚡=HNSW) · DB size · Tests · MCP on/total |
🐝 Swarms N | Active swarms — running, non-orphaned entries in swarm-state.json (coordination containers) |
🤖 Agents M | Non-terminated agents in the registry (the workers inside swarms) |
FAQ
swarmdo turns Claude Code into a coordinated multi-agent system. One prompt spawns a swarm of named agents — researcher, architect, coder, tester, reviewer — that coordinate over messages, share persistent vector memory, and learn from what worked.
Yes — it’s built for it. swarmdo registers as an MCP server (200+ tools), ships agents and skills into .claude/, and adds slash commands like /sDo:statusline. Codex runs alongside through the dual-mode package.
Yes. One command — swarmdo integrations install all --apply — wires swarmdo into OpenAI Codex CLI, GitHub Copilot CLI, and pi: each gets an AGENTS.md plus its own MCP config (Codex → ~/.codex/config.toml, Copilot → ~/.copilot/mcp-config.json), so the full MCP tool set works there too. Every merge is idempotent, dry-run by default, and it never touches your Claude Code setup.
Yes — through a shared, cross-session mailbox. A Claude Code, Codex, Copilot, or pi session messages another by name: swarmdo comms send -t reviewer -m "PR ready" (send to all to broadcast), then comms inbox or comms watch to receive. Sessions on the same repo share .swarmdo/comms/; non-Claude agents set SWARMDO_AGENT=<name> for a stable identity.
No. swarmdo is a standalone CLI and MCP server, so any AGENTS.md-aware agent — Codex, Copilot, pi — can drive its memory, swarm, and git-analysis tools. Claude Code just gets the richest surface (slash commands, statusline). swarmdo integrations skills --apply also deploys ~20 curated cross-agent skills to ~/.agents, ~/.codex, and ~/.pi, and dual-mode runs Claude and Codex workers in parallel on one task with shared memory.
MIT licensed, based on the original popular ruflo — attribution preserved in LICENSE and NOTICE. Every engine is vendored in the repo; nothing phones home.
The vector engine family: an embedded vector database with HNSW indexing and ONNX embeddings, plus a pgvector-compatible Postgres extension — CREATE EXTENSION swarmvector — with 230+ SQL functions, verified on PostgreSQL 16.
npx swarmdo init --wizard, then claude mcp add swarmdo -- npx -y @swarmdo/cli@latest. Ask Claude Code to “use a swarm” and swarmdo does the coordinating.
🇦🇺 New · open weights · built in Australia
Open, self-hostable coding models — where every gain is proven by running the tests. A1 is the coding tier (re-base +25pp, exec-verified selection +50%, p=0.0005). A2 now carries code and vision in one checkpoint, with measured proof that combining them degraded neither. Negatives included.