Your AI writes the code.
Swarm proves it actually works.
Seventeen specialized agents. Council-based deliberation. Mutation testing. Code graph awareness. Every task verified before the next begins. Coordinating agents is solved—verifying their output isn't.
What's New in v7.0
150+ releases. The philosophy didn't change. The scope of what it enforces did.
17 Specialized Agents
Up from 9. Hallucination verifier, drift verifier, sounding board critic, knowledge curator, and a two-agent council system. Each with its own permission boundary.
/swarm pr-review
Pass a GitHub PR URL or shorthand. Six parallel exploration lanes, independent reviewer, critic challenge, structured report. --council flag assumes the work is wrong.
/swarm issue
Give it a GitHub issue URL. It extracts symptoms, localizes the fault, produces a fix spec, and optionally moves into planning and execution. --trace runs the full fix.
Council Deliberation
Multi-model panel with independent web search and deliberation rounds. Based on N-Way Self-Evaluating Deliberation (arXiv:2601.16863). Real disagreement, not smoothed consensus.
Code Graph Awareness
Structural repo graph built at session start, updated on writes. Import parsing across TS, JS, and Python. Symbol extraction. Agents no longer read your codebase blind.
Mutation Testing Gate
Optional gate that blocks phase completion until tests are validated against generated mutations. Closes the gap between "tests pass" and "tests cover what changed."
Process Reward Model
Mid-execution trajectory correction. If a task drifts wrong before hitting a hard gate, PRM catches the deviation early instead of waiting for reviewer rejection.
Hallucination & Drift Verification
Dedicated agents verify API calls against real sources and catch spec divergence before it compounds. No more hallucinated endpoints or drifted implementations.
Write Authority Enforcement
Every write call is authority-checked. Symlink traversal blocked. Universal deny prefixes for .env, secrets/, .git/config. No agent touches what it shouldn't.
Different Models Review
Coder and reviewer use different AI models. Different training data means different blind spots get caught. Phase-level council is now a separate layer on top.
15+ QA Gates Per Task
Syntax, imports, linting, build checks, security scans, reviewer, tests, and now council review at phase completion. REJECT blocks. CONCERNS blocks unless configured otherwise.
Security Built-In
Offline SAST scanning, secret detection, security-focused code review, and now write authority enforcement with symlink protection. Nothing ships with vulnerabilities.
Persistent & Resumable
All state in .swarm/. Code graph at .swarm/repo-graph.json. Every task, gate, and review serialized. Close your laptop, come back next week—pick up exactly where you left off.
Learns From Mistakes
Retrospectives after each phase. Knowledge curator consolidates lessons across phases. Swarm-level knowledge promotes to hive-level for cross-project learning.
Transient Error Recovery
Rate limits and 503s get a separate retry budget that doesn't touch the circuit breaker. Infrastructure outages during long sessions no longer kill the run.
Why Swarm Wins
Coordinating agents is solved. Verifying their output isn't. That's the gap we fill.
| Capability | v7.0 OpenCode Swarm | Swarm Tools | GSD | Oh My OpenCode | Claude Code Agent Teams |
|---|---|---|---|---|---|
| Multi-agent system | |||||
| Dedicated QA pipeline (15+ gates) | |||||
| Different model for review vs. coding | |||||
| Council-based deliberation | |||||
| Code graph / structural awareness | |||||
| Mutation testing gate | |||||
| Hallucination & drift verification | |||||
| PR review command | |||||
| Persistent state & session resumption | |||||
| Evidence trail (every gate serialized) | |||||
| Security scanning built in | |||||
| Cross-project learning system | |||||
| Process Reward Model | |||||
| Write authority enforcement | |||||
| 6,000+ plugin tests |
Comparison based on publicly available documentation and capabilities as of v7.0.= Partial support
Structural Awareness & Institutional Memory
Code graph gives agents eyes. The knowledge system gives them memory. Together, Swarm gets smarter with every project.
Code Graph
Built at session start. Updated on every write. Persists at .swarm/repo-graph.json.
- Import parsing across TypeScript, JavaScript, and Python
- Symbol extraction for structural awareness
- Auto-injected into coder and reviewer context
- Incremental updates—no full rebuilds on file writes
- Survives session restarts
Two-Tier Knowledge
Lessons flow from project-level to organization-level. A dedicated curator agent consolidates knowledge across phases.
Max 100 entries. Project-specific. Retrospectives capture lessons with confidence & utility scoring.
Max 1,000 entries. Cross-project. Smart injection into future projects. Deduplication, quarantine, auto-pruning.
Confidence Scoring
Each lesson gets a reliability score. High-confidence knowledge carries more weight in future decisions.
Knowledge Curator Agent
Dedicated agent consolidates lessons across phases. Deduplicates, quarantines low-quality entries, auto-prunes.
Smart Injection
Relevant hive knowledge is injected into new projects automatically. Your org builds institutional memory, not tribal knowledge.
Other tools start fresh every session. Swarm carries forward what it learned\u2014across phases, across sessions, across projects. The code graph means it understands your architecture. The knowledge system means it remembers what worked.
How It Actually Works
From your request to production-ready code\u2014with council deliberation, mutation testing, and a full evidence trail.
You Ask
"Build me a JWT auth system." Or pass a GitHub issue URL with /swarm issue. Swarm extracts symptoms, localizes the fault, and builds a fix spec.
Explorer + Code Graph
Repo graph builds at session start with import parsing across TS, JS, and Python. Symbol extraction gives agents structural awareness—no more reading your codebase blind.
SME + Council Consults
Domain experts provide guidance. For architectural decisions, /swarm council convenes a multi-model panel with independent web search and deliberation rounds.
Plan Reviewed by Critic
Architect writes a phased plan. Sounding board critic pushes back before escalations happen. Two-agent council system handles deliberation-based planning.
Code, Review & Test
Coder implements one task. Different model reviews. Test engineer writes tests. Hallucination verifier checks API calls. PRM catches trajectory drift mid-execution.
Phase Council Review
Per-task Stage B gates always run. Then phase-level council review fires at phase_complete. REJECT blocks. CONCERNS blocks unless configured otherwise. Two layers, not one.
Mutation Testing Gate
Optional: phase_complete blocks until the test suite validates against generated mutations. Answers the question most test suites can't: do these tests actually cover what changed?
Ship with Evidence
Every task, gate, and review serialized to .swarm/. Documentation updated. Retrospective captured. Knowledge curator consolidates lessons. Full evidence trail.
Get in Touch
Have questions? Want to contribute? We'd love to hear from you.