BMAD-Tracker: The Control Layer for BMAD-Based AI Software Delivery

What BMAD is, at a high level

BMAD stands for Breakthrough Method of Agile AI-Driven Development. At a high level, it is a planning and execution framework for teams that want to use AI in software delivery without losing structure, traceability, or control.

Instead of treating AI as a code-generating black box, BMAD uses explicit planning artifacts: epics, stories, acceptance criteria, and supporting context. The goal is simple: keep the system grounded in human-defined work, then let AI accelerate the parts that can be automated.

That matters because most agentic-coding workflows break down in the same places:

• requirements drift
• unclear ownership
• hard-to-trace AI decisions
• inconsistent status reporting
• weak feedback loops between humans and models

BMAD addresses the process side. BMAD-Tracker addresses the operational side.

What BMAD-Tracker does

BMAD-Tracker (objectedge/bmad-tracker) ingests BMAD planning artifacts directly from GitHub repositories and turns them into a live execution surface.

It reads:

• stories and epics from markdown
• YAML metadata when present
• repo changes and artifact updates over time

Then it renders that work into a Jira-style Kanban board with:

• epic swim lanes
• drag-and-drop status updates
• status-aware cards
• a dashboard with:
  • status breakdown
  • epic progress
  • activity feed
  • stale stories

In practice, that gives PMs, developers, and ops leaders one place to see what BMAD plans actually look like in flight.

The value is not “another project board.” The value is visibility from planning artifact to execution state.

The stack: evidence of a real product, not a demo shell

BMAD-Tracker is built on a stack that reflects production intent:

• Frontend: Next.js 14 + TypeScript
• UI state/data: React Query, Zustand
• Drag and drop: @dnd-kit
• Backend: NestJS 10 + Prisma + Passport + BullMQ
• Data: Postgres + Redis
• Delivery/mono-repo: Docker + Turborepo

That combination says a lot.

Next.js 14 and TypeScript provide a modern, maintainable UI layer. React Query and Zustand split server state and client state cleanly. @dnd-kit supports the core board interaction model. On the backend, NestJS 10 gives structure for APIs and services, Prisma keeps the data layer explicit, Passport handles auth, and BullMQ supports background jobs and asynchronous processing. Postgres and Redis provide the persistence and queue/cache foundation you expect for a system that has to ingest, transform, and serve workflow data reliably.

This is not a toy wrapper around an LLM. It is an application architecture built to manage real work.

The AI layer is designed for cost control, not just capability

A lot of AI products focus on “more intelligence” and ignore unit economics. BMAD-Tracker takes the opposite approach: it is intentionally cost-aware and multi-provider.

Key techniques include:

• Webhook batching to reduce unnecessary processing
• SHA-256 content hash caching to avoid reprocessing unchanged artifacts
• Prompt compression to keep token usage down
• a model router to select the right provider for the task
• confidence-scored AI-derived status instead of pretending the model is always right
• a human feedback loop through AiCorrection rows

That last point matters most.

If the model classifies a story incorrectly, the correction is persisted. The system learns from the human override rather than discarding it. This is how you move from “AI output” to “AI-assisted workflow.”

BMAD-Tracker also makes the AI decisions explainable in the UI:

• reasoning tooltips show why a status was derived
• a confidence gradient helps users spot uncertain classifications quickly

That creates a practical trust model. Users do not need to believe the model. They need to understand it well enough to use it.

How the experience works

From the user’s perspective, BMAD-Tracker behaves like a lightweight execution control plane.

1. It ingests BMAD planning artifacts from GitHub.
2. It parses epics and stories from markdown, plus YAML when available.
3. It maps work items into a board structure.
4. It infers or applies status.
5. It displays progress across epics and stories.
6. It updates through drag-and-drop when humans override the state.

The dashboard closes the loop by surfacing:

• how much work is in each status
• where each epic stands
• what changed recently
• which stories have gone stale

That is the kind of operational visibility teams need when they are trying to run AI-assisted delivery at speed.

Example: Current progress: Phase 1 complete, Phase 2 underway, Phase 3 planned

BMAD-Tracker is not aspirational. It is already moving through defined delivery phases.

Phase 1: complete

Phase 1 delivered 27 stories, including:

• OAuth
• onboarding
• parsing
• Kanban board
• dashboard
• activity feed

That is the foundational surface area: identity, ingestion, workflow visualization, and monitoring.

Phase 2: in progress

Phase 2 spans 10 epics and 65 stories. Key areas include:

• AI extraction engine
• free model cost shield
• git reality engine
• transparent AI UX
• story generation
• sprint intelligence

This phase is where BMAD-Tracker gets sharper about AI quality, better at handling repository truth, and more useful for planning and execution decisions.

Phase 3: planned

Phase 3 focuses on collaboration and operating cadence:

• WebSockets for live collaboration
• auto-sync webhooks
• sprint planning
• team workspace management

That phase moves BMAD-Tracker from a strong workflow tool into a shared operational workspace.

Why this matters

Three trends are converging:

1. Agentic coding is going mainstream.
   Teams are using AI to draft code, generate stories, infer status, and accelerate delivery.

2. Visibility is now a product requirement.
   If AI is participating in the delivery process, leaders need traceability, confidence, and human override paths.

3. PM, Dev, and Ops need one shared source of truth.
   Planning artifacts, execution state, and AI reasoning cannot live in separate tools if you want reliable throughput.

BMAD-Tracker matters because it sits at that intersection.

For PMs, it makes BMAD planning tangible.
For developers, it reduces context-switching and gives a cleaner execution surface.
For engineering and operations leaders, it provides the audit trail and status visibility needed to trust AI-assisted workflows.

This is the practical version of agentic development: not hype, not autopilot, but a system that keeps humans in control while AI removes friction.

Try it, review it, challenge it

If you are building with BMAD, exploring agentic coding, or trying to make AI-assisted delivery visible to the business, BMAD-Tracker is worth a look.

Use it to:

• inspect how BMAD artifacts become executable work
• evaluate the Kanban and dashboard model
• test the explainable AI status flow
• assess whether the cost-aware architecture fits your team’s needs

If you want to discuss how BMAD-Tracker could fit into your delivery process, or you want a demo of the workflow from GitHub artifact to board and dashboard, reach out to Object Edge. We’re actively shaping the next phase and would welcome technical feedback from PMs, developers, and agentic-coding builders.