BMad Loop, Explained: How the BMAD Method Runs Agentic Software Development

The BMAD method has already changed how a lot of people plan software with AI agents. Its newest update changes how software gets built. At the core of the Bmad method is the BMad Loop which runs the software build cycle on its own, with no one pasting in the next command.

You hand the BMad Loop a set of stories and it works through them one at a time, writing the code, reviewing it, and committing it. It’s a big jump from where AI coding tools were a year ago.

This piece explains what the BMAD method is, what the BMad Loop does, and how a run takes a single story from implementation through review to a commit, then looks at how to get even more out of it once a whole team is involved.

What Is the BMAD Method?

The BMAD method (short for Breakthrough Method for Agile AI-Driven Development) is an open source framework that runs software development through specialized AI agents, making product, architecture, and design decisions explicit before any code is written.

The BMAD method brings specialized perspectives into the work: product, architecture, UX, development, and testing. Its suggested order of agent engagement clarifies the idea first, plans it, then builds and verifies, so each perspective weighs in before the code exists.

The reason it works so well is because of the strict order. It catches scope and design questions early, while they are still cheap to change. By the time code gets written, the hard decisions are already made. That is the trade the BMAD method asks you to accept: spend more time and more tokens on planning than on the code itself, because a wrong decision is far more expensive once it ships.

What Is the BMad Loop?

The BMad Loop is the part of the BMAD method that runs the build cycle unattended, picking each story, implementing it, reviewing it, and committing it without a human approving every step.

The BMad Loop is a big step forward for the BMAD method. The method started by just making planning a discipline, but it now runs the whole build cycle.

The BMad Loop works on runs. A run is one unattended pass through a queue of stories, and it starts from the stories the BMAD method's planning phase produces. The BMad Loop takes the next story, opens a session with your coding agent, and lets it implement the work. When the code is written, the loop checks that the change is real and that your tests and linter pass before it commits and moves to the next story. It works with the coding agents most teams already use, including Claude Code and Codex.

Then it moves to the review step. It hands the finished code to separate reviewer agents that check it independently, and they catch real problems rather than cosmetic ones.

The Loop Works, Until It Stops and Asks You

All of that makes BMad Loop worth using. But it also runs into a limit that has less to do with the loop and more to do with how software teams work.

When BMad Loop hits a decision it cannot make on its own, it stops and asks. The project takes this seriously enough to sort escalations by type: the ones it can live with get logged and the run continues, while the ones it cannot pause the run and page a human. In published walkthroughs of real runs, the stops turn out to be the right call.

The trouble is not that the loop stops, it is what the stops are about. In one published run, the loop stopped on a branch naming question, which is a developer's call. It also stopped because a feature depended on a capability the spec never mentioned, which is a product question. And it stopped on a gap in what the system returned to other services, which is closer to an architecture and security review.

The Catch: BMad Loop Can Only Ask One Person

BMad Loop escalates every decision to the same person, the developer running it, even when the decision belongs to someone else.

When BMad Loop needs a person, it raises a desktop notification and writes to an attention file on the machine running it, and a story can even park in a state that waits on an operator to go do something outside the loop's reach. That operator is whoever is physically at that machine. The project's own documentation is explicit that this is machine-local: a story parked on one machine is confirmed on that machine, and is unknown to others.

So the product manager never sees the scope question, the designer never sees the user-facing gap, and the security reviewer never sees the review finding. All three land on the developer, who then answers for roles that are not theirs, or guesses.

Who Actually Owns Each Escalation

Every row is a normal software decision, and those are the same perspectives the BMAD method brings into planning: product, architecture, UX, development, and testing. The loop just does not reach them once the build starts.

Making the BMAD Method Greater: Put the Right Humans in the Loop

When the loop keeps stopping, the instinct is to make it stop less. BMad Loop already ships that dial: you can set its gates to none and let everything run unattended.

That is the wrong fix. A stop means the loop found a decision that needs a human, and skipping it means shipping a guess. We need it to find the right human for each stop.

For that to happen, the loop has to run somewhere more than one person can reach. Moving it off a single laptop and into a shared environment is what turns a single-player loop into a team one.

What Changes on a Shared Platform

An agentic SDLC platform like Port is one way to do that, and three things change once the loop runs there.

Escalations reach their owner. Instead of writing its question to one machine, the loop opens a request, an action routes it to the team that owns that decision with an approval step for the person who should sign off, and the answer is logged where the rest of the org can see it. The run keeps moving while a product manager approves a scope change and a security owner clears a review finding, each in their own lane.

The loop plans against the real system. BMad Loop knows what the planning phase wrote down about one repository, which is a narrow view of the systems around it. A context lake that already tracks the wider estate and keeps it current lets the loop read what services exist, what they depend on, who owns them, and where they are deployed, instead of working from a snapshot of a single codebase.

The work becomes visible. A loop running on one laptop goes quiet when it works and leaves you digging through files when it stops. Once it runs for a team, every run, every story, and every escalation shows up in one place, along with what each run is spending.

The Next Step Is Reach, Not More Autonomy

The BMAD method already proved that better planning makes better software. The next gain is not more autonomy, it is reach. The loops that win will not be the ones that ask the fewest questions. They will be the ones that get each question to the right person fastest, so the work keeps moving while the right people decide.

FAQ

What is the BMAD method? 

The BMAD method (Breakthrough Method for Agile AI-Driven Development) is an open source framework that runs software development through specialized AI agents, making product, architecture, and design decisions explicit before any code is written. It became popular for making that thinking a required step rather than an optional one.

What is the suggested order of agent engagement in the BMAD method? 

The BMAD method's suggested order of agent engagement clarifies the idea, plans it, then builds and verifies, with learning fed back into planning. Product, architecture, UX, development, and testing perspectives come in during the earlier phases, before implementation starts.

Does the BMAD method work with Claude Code? 

Yes. The BMAD method works with Claude Code, and BMad Loop works with several coding agents including Claude Code and Codex, so you can run the loop with the agent you already use.

Where is the BMAD method on GitHub? 

The BMAD method is open source and available on GitHub under the BMad Code organization. The main framework lives at github.com/bmad-code-org/BMAD-METHOD, and the BMad Loop orchestrator lives at github.com/bmad-code-org/bmad-loop.

Is the BMAD method free? 

The BMAD method is open source, so the framework and its loop are free to install and use. You pay only for the AI coding agent you run it with.