BMad Method

Orchestrator · Last verified 2026-09-30

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

BMad Method key facts. Data as of 2026-09-30.
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-build investigates the codebase, picks a light or full planning path, implements, reviews with independent reviewers, fixes in-scope findings and commits locally. (source)
  • bmad-build-auto is 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-mode puts 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

Protocols

MCP, A2A and AG-UI support for BMad Method. See the full matrix.
ProtocolSupportNote
MCP Unknown
checked 2026-09-30
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
checked 2026-09-30
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
checked 2026-09-30
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

Install not yet verified by this site. What this means

# 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-build and bmad-build-auto halt if uv (Python 3.11+) is unavailable.
  • The Skills CLI installs only the skills you name; include bmad and the module records bmod-core-tools and bmod-method, then run bmad 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 setup offers to clean up renamed or retired skills.
  • Breaking changes land in minor releases: in v6.12.0 persistent_facts ships empty and {diff_output} became {diff_file}; the unreleased layout needs bmad migrate method on v6 projects.
  • Start bmad-build in a fresh chat; reusing a session from another workflow can mix contexts.

Official quickstart

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-build runs 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

Unknown fields: license: GitHub reports NOASSERTION; the LICENSE file is the MIT License text (Copyright 2025 BMad Code, LLC) with a contributor-attribution line and an appended trademark notice stating that BMad names and logos are not licensed (see LICENSE and TRADEMARK.md). protocols.mcp: BMad has no MCP server or client; the only MCP mentions are customization examples that direct the host agent to its own MCP tools. protocols.a2a and protocols.agui: no mentions in the README, the docs pages listed in sources, or the repository file tree; BMad is not in the AG-UI README integration list.

Something wrong or out of date, or do you maintain BMad Method and want this page removed? Report a correction or request removal.