Idea: BMAD Studio — A Visual Multi-Agent Control Center for BMAD

[kleinmenlabs]

Hi BMAD team,

I've been exploring BMAD Method, BMAD Method UI, MyBMAD, BMad Loop, and some of the community UI experiments around BMAD.

First of all: this is not a proposal to fork or modify BMAD internally.

The idea is to keep BMAD fully upstream and build a visual control layer around the existing BMAD ecosystem.

After looking at what already exists, I think there may still be an interesting gap between:

• visualizing a BMAD project,
• tracking epics/stories/workflows,
• and actually operating a team of coding agents while a BMAD workflow is running.

The idea

I'm calling the concept BMAD Studio for now.

The goal would be to create a visual control center where a developer can see and manage the agents executing a BMAD project.

For example:

Story 7.4 — Implement quotation flow

Developer
Codex
RUNNING

Reviewer
Claude Code
WAITING

Verifier
Codex
WAITING

Instead of only seeing that a story is "in-progress", Studio could expose what is actually happening underneath:

Agent
Model
Current task
Current phase
Files changed
Diff
Terminal activity
Tests
Git status
Worktree
Attempts
Token usage
Cost
Execution time

And potentially allow controlled actions such as:

Pause
Resume
Retry
Stop
Reassign agent/model
Request human attention

Why I think this may be complementary to the existing UIs

I've looked at the existing BMAD UI efforts.

BMAD Method UI / MyBMAD already cover a lot of the project visibility side very well:

• epics
• stories
• sprint status
• Kanban
• artifacts/documents
• next recommended BMAD action
• project/repository visibility

Some of the community UI experiments also go further into observability with sessions, token usage, models and costs.

So I don't think another dashboard showing the same information would add much value.

The area I'm more interested in is the execution layer.

Something closer to a control room for the agents actually performing the BMAD work.

BMad Loop makes this particularly interesting

After discovering BMad Loop, the idea became much clearer.

BMad Loop already provides much of the execution machinery:

pick story
→ development
→ verification
→ adversarial review
→ verification
→ commit

It also already supports multiple coding agents/runtimes.

So rather than inventing another orchestration engine, BMAD Studio could potentially provide a visual supervision and control layer around BMad Loop execution.

Conceptually:

             BMAD STUDIO
       visual supervision + control
                  │
      ┌───────────┴───────────┐
      │                       │
 BMAD Method              BMad Loop

methodology/artifacts execution
│
┌─────────────┼─────────────┐
│ │ │
Codex Claude Code OpenCode
etc.

Studio would not own or fork any of those components.

It would detect and interact with the installed BMAD tooling through supported interfaces.

One possible UI concept

Each running agent could have its own workspace:

Agent: Codex
Story: 7.4
Phase: Development

[ Chat ]
[ Activity ]
[ Files ]
[ Diff ]
[ Terminal ]
[ Tests ]
[ Git ]

And at project level:

RUN CENTER

Architect completed
Developer running
Reviewer waiting
Verifier waiting

Human Attention
0 requests

Story budget
$1.43 / $4.00

Tests
138 / 138 passing

The intention is not to replace the developer's IDE.

It would be more like a mission control interface for BMAD-powered agent execution.

Another principle that matters to me

BMAD Studio should never require maintaining a modified BMAD distribution.

If BMAD releases a new version, Studio should ideally detect it and continue using upstream BMAD rather than carrying a fork.

The same principle would apply to BMad Loop.

BMAD remains the source of truth for the methodology.

Studio would only provide the visualization, configuration and control layer around it.

Question for the BMAD team

Before going too far with this, I'd really like your opinion.

Is this kind of visual multi-agent execution / supervision layer already something you see becoming part of BMAD Method UI or BMad Loop?

Or do you think there is room for a separate project focused specifically on this layer?

If the direction makes sense, I'd be happy to prototype it and keep it aligned with the BMAD ecosystem rather than building something that duplicates work already underway.

I've attached two early UI concepts:

1. Run Center — focused on supervising a single BMAD story while multiple agents execute, review and verify it.
2. Studio Dashboard — a broader product vision showing projects, agents, stories, worktrees, costs, activity and human-attention events.

These are only early concepts, but hopefully they make the direction easier to visualize.

Would love to hear your thoughts.

[hossam-k]

Interested for developing such platform since I'm experimenting BMad for a while. and i always lack visualizing how agents are collaborating and even the total cost of a project.

[capitaharlock]

The pause/resume/reassign actions you listed are where this stops being a visualization problem and becomes a control-plane problem. You can render agent, model, cost and test activity from a log stream, but you can't safely pause and resume from one. If the only persisted state is the terminal output, then pause is really just stop, and resume means replay from the top.

So the first question worth nailing down is what state each action needs. A small finite state machine per agent, running -> paused -> resuming, plus a checkpoint durable enough to survive a model or target reassign. That matters more than the UI surface, and it only stays a control layer if BMAD's runner exposes enough state for an external process to hold those checkpoints without forking it.