BMad Method
TL;DR
BMad Method is a set of agent skills and workflows from BMad Code, LLC that runs inside coding tools such as Claude Code and Codex, guiding work from brainstorming and PRDs through architecture, tickets, implementation and review. It suits developers who want written plans and review gates around AI-generated code on changes of any size.
Key facts
| Type | Orchestrator |
|---|---|
| Languages / SDKs | Python, Markdown |
| License | unknown |
| Pricing model | Open source, free |
| Orchestration pattern | Crew / roles |
| GitHub stars | 53,659 (as of 2026-09-30) |
| GitHub forks | 6,047 |
| Last push | 2026-09-29 |
| Latest release | v6.12.0 |
| Repository | bmad-code-org/BMAD-METHOD |
| Website | www.bmadcode.com |
| Documentation | docs.bmad-method.org |
| Last verified | 2026-09-30 |
Key features
- Installs as SKILL.md folders through the Skills CLI (
npx skills add bmad-code-org/BMAD-METHOD) or as plugins from the bmad-plugins marketplace for Claude Code and Codex. (source) - Five persona agents (Analyst, Product Manager, Architect, Developer, UX Designer) each expose short menu codes that start their workflows. (source)
bmad-buildinvestigates the codebase, picks a light or full planning path, implements, reviews with independent reviewers, fixes in-scope findings and commits locally. (source)bmad-build-autois an unattended worker for one ticket; an orchestrating coding session dispatches one worker per ready ticket from the ticket tree and reads the plan status afterwards. (source)bmad-party-modeputs several personas in one conversation, either voiced by one model or as separate subagents, with an agent-team mode for Claude Code. (source)- Team customizations are TOML override files under
_bmad/custom/, for example persistent facts or post-completion steps that call MCP tools the host already has. (source) - Web bundles repackage planning skills as Gemini Gems or ChatGPT Custom GPTs so briefs and PRDs can be drafted outside the IDE. (source)
Architecture and orchestration pattern
Pattern: Crew / roles
BMad has no runtime process of its own. Installation copies one directory per skill (each with a SKILL.md) into the host tool's skills folder, and bmad setup adds shared config and Python helper scripts under _bmad/. A skill does one of three things: loads a persona agent, runs a multi-step workflow, or runs a single task. The host coding agent (Claude Code, Codex, Cursor and others) executes everything.
Work flows through role-based stages: planning skills produce a brief, PRD, UX and architecture documents and a ticket tree, then bmad-build implements a unit of work and runs several reviewer passes, using subagents where the host supports them. For unattended runs, bmad-build-auto handles exactly one ticket per invocation; picking the next ticket is left to a human, a coding session acting as orchestrator, or the separate bmad-loop module. Party mode can run personas inline in one model, as independent subagents, or as a Claude Code agent team.
State is kept in files, not a database. Documents and tickets are written to _bmad-output, inside the active initiative folder when one is set. Each plan file carries a frontmatter status (draft, ready-for-dev, in-progress, in-review, built, done, blocked) that lets a run resume where it stopped. Configuration resolves through layered TOML files, and project context is kept as a verified block in the repository's AGENTS.md.
Human in the loop
The method is built around human checkpoints. bmad-build reports intent gaps, irreversible actions and footprint after investigating; anything flagged gets a written plan with open questions that the user answers and approves before implementation. For unattended bmad-build-auto runs, the docs describe dispatching a ticket with Halt after planning., waiting for a person to approve the plan, then dispatching again, and pausing after a ticket until a person says to continue. In party mode the user steers the discussion and can end it; bmad-advanced-elicitation shows proposed improvements that the user accepts or discards; bmad-walkthrough guides a human review of a commit or PR block by block.
Harnesses it can drive
- Claude Code (evidence)
- Codex (evidence)
Protocols
| Protocol | Support | Note |
|---|---|---|
| MCP | Unknown | BMad ships no MCP server or client of its own; the team-adoption guide only shows customizations that tell the host agent to call MCP tools it already has (context7, Linear, Atlassian). README, docs pages and repo tree were searched. |
| A2A | Unknown | No mention of A2A / Agent2Agent in the README, docs pages (install, skills and agents, build, autonomous loops, multi-agent discussions, team adoption) or the repository file tree. |
| AG-UI | Unknown | No mention of AG-UI in the README, docs pages or repository file tree; BMad is not listed in the AG-UI README. |
Best for
- Developers using Claude Code or Codex who want a PRD, architecture notes and tickets written before the agent writes code. (shortlist)
- Adding a plan-implement-review loop with independent reviewer passes to an existing codebase. (shortlist)
- Teams that want shared agent conventions checked into the repository as TOML overrides under
_bmad/custom/. - Running early planning in a Gemini Gem or ChatGPT Custom GPT and bringing the resulting documents into the IDE.
Not for
- Trivial edits you will review yourself; the docs recommend asking the agent directly instead of running the process.
- Building your own agent application; BMad is a set of prompts and scripts run by a host coding agent, not an SDK.
- Coding tools without skills or subagent support: unattended Build Auto halts with
no subagents.
Quickstart
npx skills add bmad-code-org/BMAD-METHOD # In the project folder: install selected skills (the CLI asks which coding tool)
npx skills add bmad-code-org/BMAD-METHOD --skill bmad --skill bmod-core-tools \
--skill bmod-method --skill bmad-build --skill bmad-ticket
# Codex alternative: install from the plugin marketplace instead
# codex plugin marketplace add bmad-code-org/bmad-plugins
# Then, inside the coding agent chat:
# bmad setup -> installs the runtime and scripts under _bmad/
# bmad status -> checks versions and suggests the next step
# /bmad-build Reject empty passwords in the login form.
# /bmad-party-mode --mode subagent "review the checkout plan"
Common pitfalls
- Needs a coding tool that supports skills, plus
uv; the Skills CLI also needs Node.js, npm and Git. Since v6.11,bmad-buildandbmad-build-autohalt ifuv(Python 3.11+) is unavailable. - The Skills CLI installs only the skills you name; include
bmadand the module recordsbmod-core-toolsandbmod-method, then runbmad setup. - Use one installation method per skill (Skills CLI or plugin marketplace) to avoid duplicate commands, and restart the tool if new skills do not appear.
- The installer does not delete skill folders from removed modules;
bmad setupoffers to clean up renamed or retired skills. - Breaking changes land in minor releases: in v6.12.0
persistent_factsships empty and{diff_output}became{diff_file}; the unreleased layout needsbmad migrate methodon v6 projects. - Start
bmad-buildin a fresh chat; reusing a session from another workflow can mix contexts.
Pros
- Free and open source; the README states there are no paywalled workflows. (source)
- Not tied to one agent: the installer writes skills for Claude Code, Codex, Cursor, Windsurf, Cline, Antigravity and other tools. (source)
- Process depth is chosen after investigating the change, so small, clear changes skip the full written plan. (source)
- Review layers are configurable, and since v6.12.0 triage logs a verdict and evidence for every finding. (source)
- Planning can run on an existing Gemini or ChatGPT subscription through web bundles, keeping IDE token use for coding. (source)
Cons
- Minor releases regularly carry breaking changes (renamed skills, removed config keys, layout migrations), so customizations need upkeep. (source)
- Unattended builds depend on host features: Build Auto halts without subagents, and agent-team party mode works only in Claude Code. (source)
- Open bug: resumed and parallel
bmad-buildruns lack attributable per-run state. (source) - Open bug in v6.12.0: the epics-and-stories skill cannot find the PRD and architecture documents written by bmad-prd and bmad-architecture. (source)
- The LICENSE file adds a trademark notice to the MIT text, so GitHub cannot classify it; the BMad names and logos are not covered by the license. (source)
Alternatives
FAQ
Does BMad Method support MCP?
It has no MCP server or client of its own. Its team-adoption guide shows customizations that instruct the host coding agent to call MCP tools the host already has, such as context7 or Linear.
Is BMad Method free?
Yes. The code is under MIT license text (GitHub shows NOASSERTION because the LICENSE file adds a trademark notice), and the README says no workflows are paywalled.
Which coding agents can run it?
Claude Code and Codex have official plugin marketplaces; the Skills CLI also installs the skills for Cursor, Windsurf, Cline, Antigravity and other tools that support skills. Party mode's agent-team option is Claude Code only.
What language is BMad written in?
The skills are Markdown SKILL.md files with TOML configuration; helper scripts are Python run through uv. There is no SDK to import.
Can BMad run a backlog unattended?
Partly. bmad-build-auto completes one ticket per invocation and never picks the next one; a coding session acting as orchestrator, or the separate bmad-loop module, must dispatch tickets. It needs a host that can run subagents.
Sources
- BMAD-METHOD GitHub repository
- BMAD-METHOD README
- BMAD-METHOD LICENSE
- BMAD-METHOD CHANGELOG
- BMad Method documentation
- How to Install BMad
- Skills and Agents reference
- Build a Change
- Autonomous Development Loops
- Run Multi-Agent Discussions
- Adopt BMad Across a Team
- Use Web Bundles
- Issue #2849: bmad-build resume and parallel runs lack attributable per-run state
- Issue #2885: bmad-create-epics-and-stories cannot find a PRD or architecture
- BMad Code homepage