Enterprise-Ready Agent Pipeline.
SwarmBoard is an enterprise AI agent platform with 14 active specialized roles, a 3-tier persistent memory system, and a 6-layer quality stack. Spec to production — zero manual handoffs, 14,854+ automated tests, 325+ API routes.
The Agent Pipeline
14 active agents work in sequence from Spec to Done. If Reviewer requests changes, the ticket loops back to Dev. If Test finds bugs, a bug ticket is auto-created and fast-tracked. The Retro agent closes the loop by updating coding standards and checklists from each sprint's findings.
3-Tier Memory Architecture
Agents do not start from scratch each sprint. SwarmBoard maintains a persistent memory system that accumulates expertise over time. Decisions, patterns, and team knowledge flow forward automatically.
Working Memory
The blackboard. During an active sprint, agents share real-time signals: findings, decisions, blockers, handoffs. File-change tracking and agent identity provide a full audit trail. Pruning controls prevent signal overload.
Episodic Memory
Sprint retrospectives produce structured learnings. The Retro agent extracts patterns from review findings, quality gate failures, and ticket histories. These become coding standards, review checklists, and architecture rules that evolve automatically.
Long-Term Memory
Project context, accumulated team expertise, and conflict resolution history persist across all sprints. Knowledge onboarding injects relevant context at sprint start. Quality improves automatically as the knowledge base grows.
How Memory Flows
Each sprint's learnings are automatically injected into the next sprint's agent prompts. No manual curation required — though you can curate for better results.
PM-First: The Control Shell
SwarmBoard is designed for PMs and engineering managers, not just developers. Submit a spec, watch the board, review PRs. No IDE, no terminal, no manual handoffs.
Blackboard Dashboard
A real-time view of what every agent is doing. Signals surface findings, decisions, blockers, and handoffs as they happen. Pruning controls let you focus on what matters. Conflict resolution highlights when agents disagree.
Artifact Preview
Preview agent-generated code, tests, and documentation as they are produced. See exactly what will be committed before it hits your repository. No surprises.
Enterprise Stack Roadmap
Node.js/TypeScript is fully supported today. C# (.NET) support is first on the enterprise roadmap, followed by Java (Spring). Built for teams that ship in more than one language.
BYOK + Multi-LLM
Bring your own Anthropic, OpenAI, or Google API keys. Assign 3 different providers to different agent roles. Your keys, your billing, zero vendor lock-in.
All 14 Agents
14 active agents handle the full sprint lifecycle. 0 more are planned or in development. Each agent has a distinct prompt, toolset, and execution model — no jack-of-all-trades.
Active Agents (14)
Parses specs and meeting transcripts into structured requirements
Creates and prioritizes tickets from your spec
Multi-LLM architects (Claude × GPT-4o) debate your system design before any code is written
Writes production code and pushes to branches
Reviews code diffs and catches issues
Runs tests and verifies acceptance criteria
Rebases and merges approved PRs to main
Checks cross-ticket integration coherence
Marks tickets done and coordinates cross-ticket work
Logs learnings and improves the pipeline over time
Coming Soon
Auto-generates documentation from code changes
Handles automated deployments and rollbacks
Scans code for vulnerabilities and security issues
Visual regression testing with screenshot comparison
Self-healing: monitors pipeline health and restarts failed agents
Why SwarmBoard?
Enterprise-grade autonomous pipeline with full accountability, persistent memory, and quality controls at every stage.
Specialized Agent Roles
14 active agents, each with distinct tools, prompts, and execution models. PM uses ticket APIs. Dev uses git. Reviewer reads diffs. No jack-of-all-trades.
6-Layer Quality Stack
Lint gate, per-ticket code review, cross-boundary impact analysis, sprint-wide verification, retrospective learning, and memory transfer. 14,854+ automated tests.
3-Tier Memory System
Working memory (blackboard), episodic memory (sprint learnings), and long-term memory (project expertise). Agents accumulate knowledge and quality improves automatically.
Human-in-the-Loop
Review mode puts you in control. Approve PRs, adjust priorities, halt or resume the sprint at any checkpoint. Enterprise approval gates supported.
GitHub-Native Workflow
Feature branches, PRs, and CI built in. Your repo stays clean, auditable, and under your full control. No proprietary lock-in.
Multi-LLM + BYOK
Claude, GPT-4o, and Gemini with per-role model configuration. Bring your own API keys. 3 providers, zero vendor lock-in.
Architecture Evolution
Key capabilities shipped across 665+ stories, spanning infrastructure, agent intelligence, memory system, enterprise features, and quality pipeline improvements. Built with its own pipeline.
Phase B Memory System
Persistent working memory, episodic memory, and conflict detection across sprints. Knowledge onboarding integrates learnings at sprint start. Retro agent feeds learnings back into agent context automatically.
Sprint Blackboard & Signal Intelligence
Real-time agent coordination via a shared blackboard. Signals include findings, decisions, blockers, and handoffs. File-change tracking and agent identity provide full audit trail.
Multi-LLM Support
Claude, OpenAI GPT-4o, and Google Gemini with per-role model config. Provider-specific SDK routing. Generic coding agent for non-Anthropic CLI roles.
Persistent Sprint Workspaces
Single git bare clone per sprint, worktrees per ticket, DB-level locking. Docker named volumes survive container restarts. Branch reuse on retry preserves prior code.
Dev Agent Intelligence
Surgical fix mode for small changes (5-turn cap, 5-min timeout). Session context injection (previous attempts, user feedback, branch diff). Frequent commit discipline protects work from timeouts.
Architecture Debate Engine
Multi-LLM adversarial review: Proposer (Claude) vs Challenger (GPT) vs Rebutter (Claude) vs Arbitrator (Gemini). Catches spec gaps before coding begins.
Review Pipeline Intelligence
4-pass review: code quality, spec compliance, runtime analysis, security checks. Auto-fix traceability links changes back to original findings.
Protected File Guard
Project owners define protected files in .swarmboard/protected-files.txt. Agents cannot modify pipeline-critical files, preventing accidental self-modification.
BYOK & Enterprise Stack
Bring your own API keys for Anthropic, OpenAI, and Google. Enterprise stack roadmap: C# (.NET) first, Java (Spring) next. PM-first UX with no IDE required.
Artifact Preview & Blackboard Dashboard
Live preview of agent-generated artifacts. Blackboard dashboard surfaces real-time signals, decisions, and blockers with pruning and conflict resolution controls.
Interactive Blackboard (Sprint 64)
Human-agent coordination surface with signal posting, directives with lifecycle management, decision resolution into ADRs/tasks, agent activity monitoring, performative-typed communication, and real-time SSE updates.
Meeting Data Layer (Sprints 61-63)
Full meeting transcript pipeline — manual upload, webhook ingestion from Zoom/Teams/Fireflies, date-based browsing, full-text search, analyst integration for spec extraction, and pluggable storage backends (local, S3, Azure).
Platform MCP Server & Zero Tech Debt
8 MCP tools wired into agent sessions — signal_post, ticket_update, ticket_transition, ticket_search, memory_query, memory_record, working_memory_read, working_memory_write. Cross-model routing wired. Platform reached zero known tech debt with 14,854 passing tests.
The Five Pillars
Every line of SwarmBoard code is governed by five architectural principles. These are non-negotiable rules enforced by automated verification scripts on every commit.
Every state has a lifecycle
No orphaned statuses. Every ticket, session, reservation, and membership has documented entry paths, exit paths, and cleanup rules.
Every boundary has a contract test
Producer and consumer are tested independently. If an API returns a shape, a test verifies the consumer expects that shape.
Wire both ends or wire neither
Never build a module without connecting it. Every API endpoint has a consumer. Every service function is called.
Fail loud, recover gracefully
Permanent errors throw immediately. Transient errors retry with backoff. Orphaned sessions are cleaned up on restart.
Budget is a first-class citizen
Every token is reserved before use, settled after completion, cancelled on failure. No agent runs without budget approval.
Quality Architecture
Agent Roles & Tools
| Role | Execution | Tools |
|---|---|---|
PM | Raw API (Claude/GPT-4o/Gemini) | ticket_create, ticket_update, ticket_list, ticket_transition, signal_post |
Architect | CLI / Generic | File read/write, git, bash (CLI or generic coding agent) |
Dev | CLI / Generic | File read/write/edit, git clone/commit/push, bash, surgical mode |
Reviewer | Raw API (Claude/GPT-4o/Gemini) | git_diff, file_read_github, review_finding_create, cross_boundary_check, runtime analysis, security scan |
Test | CLI / Generic | File read/write, git, bash (CLI or generic coding agent) |
Merge | CLI / Generic | git rebase, git merge, PR management |
Verifier | Raw API | ticket_list, signal_post, review_findings_list |
Integration | CLI / Generic | File read/write, git, bash — catches cross-service wiring gaps |
Retro | Raw API | ticket_list, signal_post, review_findings_list, checklist_update, standards_update, rules_update, retro_save |
| Chat | Raw API (Claude/GPT-4o) | project_query, ticket_search, sprint_status, explain_code |
6-Layer Quality Stack
| Layer | Name | Scope | Description |
|---|---|---|---|
| Layer 1 | Quality Gate | Per-ticket | Lint + typecheck + tests before review |
| Layer 2 | Reviewer Pass 1 | Per-ticket | Diff review against acceptance criteria |
| Layer 3 | Reviewer Pass 2 | Per-ticket | Cross-boundary impact analysis |
| Layer 4 | Verifier | Per-sprint | Integration coherence check across all tickets |
| Layer 5 | Retro Agent | Per-sprint | Pattern analysis, checklist + standards evolution |
| Layer 6 | Memory Transfer | Cross-sprint | MCP-wired memory tools (T-410) enable agents to query and record patterns mid-session. Retro agent distills sprint learnings into next sprint's agent context. FTA agents carry forward accumulated knowledge. |
Quality Stack
Autonomous Mode
Agents run the full pipeline without human intervention. Best for MVPs, internal tools, and rapid prototyping. Catches ~75% of bugs automatically.
Review Mode
Human reviews agent-generated PRs before merge. Best for production and client-facing projects. Bug detection rate of 90%+ with human review.
How Quality Improves Over Sprints
Base quality from spec. Agents follow standard best practices.
Retrospective agent adds review checklist items and coding standards learned from previous sprint findings.
Auto-generated contract tests catch known bug patterns. Architecture rules prevent repeated mistakes.
Quality plateaus at 75-80% autonomous, 90%+ with human review. The platform has learned your project's patterns.
Where to Focus Your Effort
Write detailed specs with acceptance criteria -- agents are only as good as the spec
Use review mode for production and client-facing projects
Use autonomous mode for MVPs, internal tools, and rapid prototyping
Review stuck signals and triage promptly -- don't let tickets rot
Curate the architecture rules the Retro agent generates -- remove noise, keep signal
Choose models wisely: Haiku for speed/cost, Sonnet for balance, Opus for complex architecture
The Numbers
Built with its own architecture
SwarmBoard was built across 665+ stories using its own multi-agent pipeline. Every story follows the Five Pillar rules, every phase passes a 4-pass review gate, and every fix is tracked in a structured backlog. The 3-tier memory system (working memory, episodic learning, long-term expertise) is now live. The platform actively dogfoods its own autonomous sprint delivery at scale.