SwarmBoard is an autonomous delivery platform — 10 specialized agents operating inside a governed pipeline. Every ticket moves through 8 enforced stages from intake to production. Humans approve at every gate.
Every project moves through an enforced delivery pipeline. Tickets can only move forward through validated transitions, and automatically move backward when quality checks fail.
A 4-path onboarding wizard (Write a Spec, API Specification, Existing Repo, or Repo + Spec) guides the team through project setup. For existing codebases, the brownfield analysis engine clones your repo and runs deep analysis — detecting 25+ frameworks across 30+ languages, mapping module dependencies, identifying dead code and unwired features, and producing a complete tech stack profile.
Choose the intake path, provide the repo URL or spec text, answer the Analyst agent's clarifying questions.
Analyst confirms scope is understood before proceeding.
The Context Service generates a living system document (CLAUDE.md) that maps modules, structural relationships, and key architectural decisions. For brownfield projects, the Reconciliation engine compares what your codebase already does against what your spec asks for — surfacing what's covered, what's partially built, and what's genuinely new work.
Review the generated context, correct any inaccuracies, confirm the system understanding is accurate.
Human reviews and accepts the context pack.
The Analyst agent engages in structured chat to refine ambiguous requirements. For complex architectural decisions, the Architecture Debate system pits two AI architects against each other (Claude vs. GPT) — each argues for their approach with diagrams and trade-off analysis. A neutral synthesis captures the best of both and is saved as a project artifact.
Answer analyst questions, watch the debate unfold, confirm the final spec with a single click.
Human approval required. The spec cannot proceed until explicitly confirmed — this is a hard gate.
The PM agent (or Chat agent via natural language) breaks the confirmed spec into typed, prioritized tickets with acceptance criteria, dependency links, and estimated complexity. Tickets are created with parent-child relationships and dependsOn fields that the orchestrator respects during execution.
Review tickets, adjust priorities, add or remove items, approve each ticket for sprint inclusion.
Human approval required. Each ticket must be explicitly approved before agents can work on it.
When the human clicks Start Sprint, the orchestrator bulk-transitions approved tickets to dev-ready and dispatches Dev agents in priority order. Each Dev agent works in an isolated git worktree. The system enforces dependency ordering, WIP limits, budget monitoring, auto-retry on failure, and auth error detection.
Monitor the board, watch the blackboard for signals, triage stuck tickets (reassign, split, escalate, or deprioritize).
Quality Gate runs lint, typecheck, and tests on every commit. Failures block progression.
The Reviewer agent performs adversarial, multi-pass code review — checking architecture impact, security, performance, database patterns, and API contracts. Cross-model diversity prevents rubber-stamping: Reviewer uses GPT-4o, Verifier uses Gemini 2.5 Pro. After approval, the Test agent runs the full test suite. Cycle limits enforced: 3 review rounds max, 2 test rounds max.
In Review delivery mode, humans review PRs before merge. In Autonomous mode, the pipeline handles it end-to-end. Humans can override any ticket at any time.
Reviewer approval + test pass required. Cycle limits enforced — then human triage.
The Merge agent processes approved tickets through a serial merge queue — one at a time to prevent rebase conflicts. After all tickets are done, the Sprint Verifier checks cross-ticket coherence. Then the Retro agent analyzes the entire sprint — extracting learnings, adding quality checklist items, and updating coding standards.
Review the sprint report and retro findings. Accept or reject retro-generated rules.
Sprint verifier coherence check. Retro findings reviewed by human.
The sprint auto-closes when all tickets reach done and the verification pipeline completes. Workspace directories are cleaned up. A completion signal is posted to the blackboard. If tickets are stuck or blocked, they remain visible for the next sprint's planning.
Decide whether to start the next sprint, replan blocked work, or adjust scope.
Human decision to proceed.
The pipeline doesn't just handle the happy path. Every failure mode has a defined response — automatic recovery where possible, human escalation when needed.
| Failure | System Response | Resolution |
|---|---|---|
| Agent session crashes | Ticket rolls back to ready state, auto-retries up to 3 times | Auto-Recover |
| Reviewer rejects code | Ticket returns to dev with findings, re-dispatches automatically | Auto-Recover |
| Tests fail | Ticket returns to dev with full stderr, diffs, and prior context | Auto-Recover |
| Max review cycles hit (3) | Ticket escalated as stuck — human triage required | Human Triage |
| Max test cycles hit (2) | Stuck signal posted, human must intervene | Human Triage |
| Budget exhausted | Dispatch auto-pauses, blocker signal posted to board | Human Triage |
| Auth credentials expire | Immediate block — no wasted retries | Human Triage |
| Merge conflict | Merge agent auto-retries rebase; if persistent, blocks for human | Auto-Recover |
| Parent ticket blocked | All child tickets stay queued — dependency ordering preserved | Auto-Recover |
| Sprint halted by human | All in-progress tickets halt, resume to exact prior state | Manual |
10 specialized agents, each with a distinct role and default model. Every agent is configurable per-project: enable/disable, set the model tier, and control concurrency.
Refines specs, asks clarifying questions, confirms scope
Architecture debate, system design decisions
Creates and grooms tickets, manages sprint structure
Writes code, commits to feature branches, creates PRs
Adversarial multi-pass code review
Runs test suites, reports failures with full context
Cross-ticket coherence check at sprint end
Serial merge queue, rebase handling
Sprint retrospective, learning extraction
Natural language interface for board operations
Request access to SwarmBoard or browse the help documentation to learn more.