CrystalSpec vs BMAD
The durable spec, not the by-product.
BMAD-METHOD orchestrates a dozen agent personas — analyst, PM, architect, dev, QA — that hand work off through markdown files. CrystalSpec is where the spec those roles produce becomes typed, versioned, and governed, and where the same agents can query it over MCP.
Free 14-day trial. No credit card. Cancel in two clicks.
BMAD runs the roles. CrystalSpec keeps what they build.
Credit first: BMAD-METHOD — the Breakthrough Method for Agile AI-Driven Development — has become one of the most talked-about ways to run a real software lifecycle through AI. It is free and MIT-licensed, sitting at roughly 50,000 stars as of mid-2026 on its public GitHub repository, with a fast-moving v6 line (v6.10 landed in July 2026). BMAD is not one bot; it is a configurable team of named personas — analyst, product manager, architect, product owner, scrum master, developer, QA — that you install into a coding tool such as Claude Code or Cursor and drive through structured, scale-adaptive workflows. A planning pass produces a brief, a PRD, and an architecture; a scrum-master persona then shards the epics into self-contained story files, and the developer persona implements them one at a time. For greenfield builds, that discipline is genuinely excellent.
Look closely at where the spec actually lives, though, and a gap opens. BMAD is a workflow that generates markdown as it runs: project-brief.md, prd.md, architecture.md, and a fan of story files, each re-carrying the slice of context the next role needs. The specification is a by-product scattered across the repo, and its governance is convention — role boundaries are prompt discipline, and the review between phases is etiquette rather than a gate. Nothing structural stops an agent from writing outside its lane, and nothing keeps prd.md true once the code moves past it. When the sprint ends, those files age exactly like any other markdown.
CrystalSpec is the durable source of truth those same roles would produce and then be on the hook to maintain. In place of a folder of files, you get one typed graph, everything cross-referenced into a single vocabulary: flows whose decision branches are labelled, data models carrying enum-typed fields that reference other models, roles, test cases, and glossary terms. Governance is baked into the architecture rather than left to etiquette — the AI is denied any write path to the spec at all. It surfaces appliability-checked create, update, and delete proposals, a human accepts or refuses each row, and every call is logged, each rejection preserved next to whoever made it. A publish mints a versioned revision bearing field-level diffs and an AI-drafted change summary, revertible with its full lineage; and any time you like, the one-click inconsistency analyzer sweeps across the whole project, grading contradictions, gaps, and glossary entries left with nothing to reference.
None of this turns CrystalSpec into a BMAD replacement, and the seam deserves candor. CrystalSpec neither generates code nor orchestrates agents — no personas, no dev loop. It supplies the agents that do. Aim BMAD's architect and developer personas at CrystalSpec through the hosted MCP server or the scoped GraphQL API and they can lift a flow, page back through revision history, and request the precise delta since their last visit — the very questions a directory of story files leaves unanswered — either in place of re-reading files or alongside it. Publish a revision and CrystalSpec splits it into atomic tasks for GitHub, Linear, or ClickUp, idempotent and back-linked. Run the pair together: BMAD drives the roles; CrystalSpec is where what they build stays honest.
Method and source of truth, row by row
| Dimension | CrystalSpec | BMAD |
|---|---|---|
| Category (mid-2026) | AI spec workspace (hosted) | Open-source multi-agent SDLC framework |
| License & price | $10/seat/mo · 14-day trial | Free, MIT — you pay for the coding tool |
| What the "spec" is | Yes: Typed graph: flows, models, roles, test cases, glossary | Partial: Markdown artifacts: prd.md, architecture.md, story files |
| Multi-agent orchestration | No: Not an orchestrator — feeds agents over MCP | Yes: A dozen named personas across the SDLC |
| Code generation | No: None on purpose — it supplies the agents that write code | Yes: Developer persona implements end to end |
| AI write gate | Yes: Appliability-checked proposals, approved row by row, logged | Partial: Between-phase review by convention |
| Governance model | Yes: Structural — AI can't write silently; permissions server-side | Partial: Prompt-enforced role boundaries |
| Spec lifespan | Yes: Durable published revisions | Partial: Per-project artifacts that age after the sprint |
| Versioning | Yes: Per-field diffs + AI change summaries; revert keeps lineage | Partial: Git commits on markdown files |
| Consistency checking | Yes: Project-wide inconsistency analyzer, graded findings | Partial: Cross-checks between agent artifacts |
| Tracker push | Yes: Back-linked atomic tasks to GitHub, Linear, ClickUp; re-run safe | No: None built in |
| Non-engineer surface | Yes: Web app, share links, PDF export, discussions | No: Terminal + repo (planning also via web bundles) |
| Maturity (mid-2026) | Focused, self-serve product | ~50k stars; v6.x, fast release cadence |
Based on the public BMAD-METHOD repository (github.com/bmad-code-org/BMAD-METHOD), its docs, and CrystalSpec's published pricing, as of mid-2026. BMAD is community-driven and ships fast — verify current details on GitHub.
Built to persist, and to govern
One source of truth, not a file fan
BMAD's brief, PRD, architecture, and story files scatter across the repo, each re-carrying context. CrystalSpec keeps one typed, cross-referenced spec every role reads from and writes to.
Governance by architecture
Role boundaries in BMAD rest on prompt discipline. CrystalSpec makes the AI structurally unable to write to the spec — it offers appliability-checked proposals, you clear them row by row, and every verdict lands on the record.
Revisions, not just commits
Git watches lines in markdown. CrystalSpec cuts versioned revisions that carry entity-level field diffs, a summary the AI drafts of what changed, and revert-with-lineage, all threaded onto a per-project timeline.
One analyzer over the whole graph
Turn the inconsistency analyzer on an entire project, or narrow it to one flow or one step. It grades contradictions, gaps, and dead glossary terms, and every finding becomes a reviewable Fix-with-AI proposal with browsable history.
Agents query, they don't re-read
Between a hosted MCP server, scoped GraphQL, and signed webhooks, BMAD's own developer and architect personas can grab a flow, enumerate revisions, and compare two versions instead of re-parsing files on every run.
Straight to the tracker
Publish a revision and CrystalSpec breaks it into atomic tasks for GitHub, Linear, or ClickUp — a second push changes nothing, and every task threads back to its revision. BMAD stops at artifacts left in the repo.
A method can produce a spec in an afternoon. It takes a source of truth to still trust it next sprint.
Two layers, two jobs — pick by the job
Choose CrystalSpec if…
- Your team and your coding agents want one durable, typed source of truth — not a folder of markdown artifacts that goes stale once the sprint ends.
- You want AI-drafted changes that each land only after a recorded human sign-off, with permissions enforced server-side.
- The spec has to stay queryable: agents lift flows, enumerate revisions, and compare versions over MCP and GraphQL.
- A published revision should turn into idempotent, back-linked atomic tasks across GitHub, Linear, or ClickUp.
- PMs and designers deserve first-class seats — threaded @mentions, shareable read-only links, a PDF handout — instead of a terminal.
Choose BMAD if…
- You want a free, open, prescriptive multi-agent SDLC workflow that runs inside your coding tool. That is BMAD's actual product, and it is a real strength.
- You are an engineer-led team comfortable configuring agent teams — analyst, PM, architect, dev, QA — in the terminal.
- You want the whole plan-and-build loop, code generation included, in one open framework; CrystalSpec deliberately does neither.
- You value the open ecosystem: an MIT licence, a large and active community, and forkable workflows you can bend to your own process.
Fair questions, straight answers
Is CrystalSpec a BMAD-METHOD alternative?
They solve adjacent problems. BMAD orchestrates agent personas that generate a spec as markdown while they build; CrystalSpec is the durable, typed, versioned source of truth those roles produce and then maintain, queryable by agents over MCP. Plenty of teams could run both — BMAD to drive the agents, CrystalSpec to hold what they are building.
BMAD is free and open source — why pay $10 per seat?
You are paying for what markdown in a repo cannot do: entities that carry types, a structural gate that makes every AI edit a human decision, revision diffs down to the field, an analyzer that grades the whole project for inconsistency, a hosted MCP server plus GraphQL, and atomic tasks pushed into GitHub, Linear, and ClickUp. If everyone touching the spec is an engineer in a terminal, BMAD alone may genuinely be enough.
Can I use BMAD and CrystalSpec together?
Yes, and they complement each other cleanly. Run BMAD's personas in Claude Code or Cursor and point them at CrystalSpec over the hosted MCP server: the developer and architect agents read flows, list revisions, and diff versions from one governed source of truth instead of re-parsing scattered files. BMAD orchestrates the work; CrystalSpec is where the work persists.
Does CrystalSpec generate code or run the agents like BMAD?
No, by design. CrystalSpec is not an agent-orchestration framework and not a code generator — it has no personas and no dev loop. Where it ends is a rigorous, queryable spec together with the atomic tracker tasks it pushes, and it feeds the agents — including ones you drive with BMAD — over MCP. If you want the whole plan-and-build loop in one open framework, BMAD is the better fit for that job.
How does governance differ between the two?
In BMAD, role boundaries and between-phase review are convention — prompt discipline that nothing structurally enforces. In CrystalSpec the AI cannot write to the spec at all; it raises appliability-checked proposals for a human to clear row by row, logging each verdict, while owner, admin, and contributor roles are checked on the server for every operation.
Which version of BMAD does this compare against?
BMAD-METHOD's v6 line — around v6.10 as of July 2026, on roughly 50,000 GitHub stars. BMAD is community-driven and ships fast, so treat the version and star figures as a mid-2026 snapshot and check its GitHub repository for the current state before you decide.
Can we move our BMAD artifacts into CrystalSpec?
There is no importer, and you will not need one. Feed a prd.md or architecture.md to the assistant; it comes back with structured entities to propose — data models, roles, test cases, flows — and you clear them one at a time. Then set the inconsistency analyzer loose to expose everything those scattered files never reconciled against each other.
The verdict
Pick BMAD to orchestrate the agents that build. Pick CrystalSpec for the typed, versioned, human-approved source of truth those agents read from — and run them together when you want both.
Start free — 14-day trial, no credit card.