Describe what you need — a PM agent plans it, specialized agents build it, with real tools, shared memory, and automatic fault recovery. Bring your own API key or run fully local with Ollama. No middleware required.
No orchestration expertise required. Write what you need in plain English.
One sentence, one paragraph, or a full spec. Drop it in the dashboard or pass it on the CLI.
crew-pm plans MVP → Phase 1 → Phase 2. Each phase gets 3–5 small, targeted tasks.
crew-coder writes code, crew-qa adds tests, crew-fixer handles bugs — each gets exactly their task.
Real files, real output. No hallucinated success messages. Failed tasks hit the DLQ for replay.
CrewSwarm sits atop a modular architecture designed for reliability and flexibility.
Agents subscribe to topics. Tasks are dispatched targeted to one agent at a time. No broadcast races, no duplicate work.
Each agent calls its configured LLM directly — Mistral, Cerebras, OpenAI, DeepSeek, Perplexity, Google, or local via Ollama. No proxy, no middleware, no extra cost.
PM planning, phased builds, PM Loop, shared memory, fault recovery, dashboard, and SwiftBar control plane. The brain of the operation.
Natural-language requirement → PM breaks it into tasks → targeted dispatch to the right agent. No broadcast races. No duplicate work.
Send to one agent by name. --send crew-coder "Build auth". Only that agent receives it.
MVP → Phase 1 → Phase 2. Failed tasks auto-break into subtasks and retry. No work is lost.
Persistent markdown files — current state, decisions, handoff — injected into every agent call. The crew stays aligned across sessions.
Retry with backoff, task leases, heartbeat checks. After max retries, tasks go to the Dead Letter Queue for replay from the dashboard.
Pick how you want to drive the crew. Every surface targets the same RT bus and the same crew — from your terminal to your phone.
Every agent calls its LLM directly — no proxy, no middleware. Mix and match freely: PM on Perplexity for web search, coders on Mistral or DeepSeek, coordinator on Cerebras for instant replies. Or run everything local with Ollama.
Industry standard. Best for general reasoning and instruction following.
Top-tier code quality and instruction following. Strong on long context.
Blazing-fast inference. Best for QA and fixer agents where speed matters.
Excellent for code generation. Codestral is purpose-built for dev tasks.
Open-source coding model with exceptional code completion quality.
Real-time web search. Ideal for the PM agent to research before planning.
Multimodal and fast. Flash is cost-effective for high-volume tasks.
Ultra-fast hardware inference. Near-instant responses for latency-critical agents.
xAI's model with real-time X/Twitter data access and strong reasoning.
Run fully local. No API keys, no rate limits, no data leaving your machine.
Each agent can use a different provider. Add API keys and assign models from the Providers tab in the dashboard — or edit the config JSON directly. Switch models at any time, no restarts needed.
CrewSwarm is open-source software. Use it, modify it, contribute to it.
Use it for personal projects, commercial products, or anything in between. No restrictions.
No subscription. No usage limits. Bring your own API keys for the LLM providers you choose.
Contributions welcome. Report issues, submit PRs, or just star the repo to show support.
Nine specialized agents, each with a role, a model, and a set of tools. The PM decides who gets what — no broadcast racing.
Chat, triage, and kick off orchestrators. Your first point of contact.
Breaks requirements into phased tasks. Assigns agents. Keeps scope tight.
Writes code, creates files, runs shell commands. The workhorse of every build.
UI, styling, and client-side code. Knows the design system and keeps markup clean.
APIs, databases, and server-side logic. Optimized for structured, deep code tasks.
Headlines, CTAs, and product copy. Keeps brand voice sharp and on-message.
Adds tests, validates behavior, and audits output before anything ships.
Diagnoses failures, fixes edge cases, patches what QA flags.
Audits for vulnerabilities, hardens configs, and enforces best practices.
Type a requirement in the Build tab, click Run. PM plans it, coder builds it, QA tests it. Watch it happen in RT Messages.
crew-fixer diagnoses and patches, crew-qa writes the test suite. Targeted dispatch means each agent does exactly one thing.
"Build a todo API with Express, CRUD endpoints, and a test file." One sentence. Real files on disk in minutes.
SwiftBar shows you CrewSwarm status at a glance. Start, stop, restart agents. Send a message to any agent. Open logs.
Max retries hit? Task goes to the DLQ. Open the dashboard, see the error, replay with one click — or fix and rerun.
Shared memory files — current state, decisions, handoff — are injected into every agent. Resume tomorrow exactly where you left off.
Build, dispatch, replay, monitor — and open any file the crew wrote directly in Cursor or OpenCode.
The only fully open-source platform where a PM agent runs the build — not just a single autocomplete suggestion.
A dedicated Project Manager agent reads your ROADMAP, breaks work into phases, dispatches tasks to the right specialists, and writes handoff notes between sessions — automatically.
Every agent reads and writes to a shared memory layer — decisions, context, and progress persist across sessions so nothing gets lost between runs.
Agents communicate over an RT message bus. Any agent can broadcast, any agent can listen — parallel work happens naturally without a central bottleneck.
Failed tasks land in a Dead Letter Queue and are automatically retried. Builds keep moving even when individual agents hit errors or timeouts.
Configure any model per agent — Groq, Anthropic, OpenAI, NVIDIA, or fully local via Ollama. No vendor lock-in, no forced subscriptions.
Manage your crew from the web dashboard, the CLI, the macOS menu bar, or Telegram. One build, every surface covered.
Pick the right tool for the job. From single tasks to full autonomous builds.
Break large work into MVP → Phase 1 → Phase 2. Auto-phases ambiguous requirements, auto-retries failed tasks, and breaks them into subtasks if needed.
node phased-orchestrator.mjs --all "Build a todo API with CRUD and tests"
One command, structured execution. PM plans it once, crew executes in sequence. No phasing overhead — good for well-defined tasks.
node unified-orchestrator.mjs "Fix auth.js bug and add tests"
Send one task directly to one agent. No PM, no planning. Fastest path from intent to execution for simple, well-scoped work.
node gateway-bridge.mjs --send crew-coder "Add GET /health to server.js"
| Mode | Best for | Auto-retry | Phasing | Overhead |
|---|---|---|---|---|
| PM Loop | Large or ambiguous builds | ✓ | ✓ | Medium |
| Unified | Well-defined tasks | ✓ | — | Low |
| Single-task | Quick fixes, small edits | — | — | None |
No proprietary runtime. No cloud lock-in. Everything runs on tools you already know.
gh
Answers pulled straight from docs/WEBSITE-FEATURES-AND-USE-CASES.md so the crew stays aligned on how CrewSwarm ships work.
No matching answers yet. Try another keyword.
The tagline is literal: you describe a requirement once and a PM-led crew handles the rest — planning, coding, QA, and fixes — until real files land on disk. Every answer in the features doc reinforces this promise.
The PM Loop reads ROADMAP.md, ships every pending item, then calls Groq as a product strategist to append fresh roadmap items based on the live output. It repeats forever until you stop it.
Four files are always injected: current-state.md, decisions.md, agent-handoff.md, and orchestration-protocol.md. The wrapper auto-bootstraps them and enforces token budgets so no agent runs blind.
CrewSwarm never shouts into a swarm. Each task goes to one named agent, eliminating race conditions and duplicate work. You send a command, the gateway routes it to exactly the right specialist, and only that agent replies.
Everything ships in three passes: MVP for the smallest viable outcome, Phase 1 for depth, and Phase 2 for polish. Each phase carries 3–5 tightly scoped tasks so agents never time out.
Failures trigger automatic retries with exponential backoff. If attempts are exhausted, the task lands in the Dead Letter Queue where you can replay it from the dashboard or hand it to crew-fixer.
From your CrewSwarm directory run:
$ node scripts/dashboard.mjsThat gives you Build, RT Messages, DLQ, Projects, Services, and Send tabs in one place.
Use the phased orchestrator:
$ node phased-orchestrator.mjs --all "Build a todo API"That single command triggers PM planning plus all subsequent coding, QA, and fixing.
Send straight to one agent:
$ node gateway-bridge.mjs --send crew-coder "Create server.js with Express and GET /health"Only crew-coder receives that instruction, so there is zero broadcast noise.
Yes. Every agent has its own model assignment — Anthropic for coding, Perplexity for planning, Cerebras for fast coordination, Groq for QA speed. Configure from the dashboard Providers tab or edit the config JSON directly. No code changes, no restarts.
Use the Projects tab in the dashboard. Every project stores its roadmap path; click “Resume PM Loop” and it picks up right where the roadmap last stopped.
The PM Loop inspects the live output, asks Groq-as-strategist for 3–5 fresh items, appends them to ROADMAP.md, and keeps shipping. You never need to re-seed work manually.
The gateway wrapper auto-creates any missing memory files from templates, logs the bootstrap event, and refuses to run a task if memory cannot load. That policy came from DEC-004/005.
A JSONL feed at ~/.openclaw/logs/events.jsonl stores bootstrap events, memory load failures, protocol violations, retries, and RT events for later auditing.
You get crew-main (coordination), crew-pm (planning), crew-coder (implementation), crew-qa (testing), crew-fixer (debugging), security (audits), plus optional specialized front/back coders.
The repo ships Phased PDD, PM Loop, Continuous Build, Unified orchestrator, and direct targeted sends. Each mode fits a different scope, from whole products to one-off fixes.
It inspects the target directory for required sections (hero, features, testimonials, etc.), dispatches tasks for anything missing, and loops until every section exists.
SwiftBar shows stack health, lets you start/stop/restart agents, open the dashboard, and even send targeted messages from the macOS menu bar.
Each project is registered with its output path and roadmap. The dashboard’s Projects tab and orchestrator-logs/projects.json keep everything resume-ready.
The loader trims each file to 2,500 characters and caps the combined memory payload at 12,000 characters, guaranteeing agents never blow their context windows.
When a task fails, the orchestrator automatically breaks it into 2–4 smaller subtasks so follow-up attempts stay within safe execution windows.
Layer 1: CrewSwarm RT — your own WebSocket message bus (port 18889). Layer 2: Direct LLM calls — each agent calls its configured provider API with your key, no proxy. Layer 3: CrewSwarm orchestration — planner, phased builds, shared memory, dashboard, and SwiftBar.
Yes. The orchestrator, dashboard, SwiftBar plugin, and memory system all run on your Mac. The only external calls are to the LLM providers you configure.
The RT Messages tab in the dashboard mirrors every command, agent reply, and issue. It’s the best place to verify what each agent just did.
From the dashboard’s Services tab, hit Restart next to any agent. You can also use SwiftBar’s per-agent controls from the macOS menu bar. Either path keeps the rest of the crew running.
From quick starts to deep dives — comprehensive guides for every part of the CrewSwarm stack.
Complete reference for the gateway-bridge CLI, RT message bus, and orchestrator APIs.
Step-by-step guides for configuration, deployment, and advanced usage patterns.
Hands-on walkthroughs to get you building with CrewSwarm quickly.
All models and agents configurable via JSON. No code changes required to switch LLMs.
View full docs on GitHub →