Roadmap

The Roadmap board is the company North Star — the journey the team follows till done, from one prompt to a shipped, delivered business. It's a top-level destination at dash.busymate.dev/roadmap: open it and you see exactly where every phase of that journey stands right now.

The North Star

Busymate is the first AI solution that takes an advanced user from an idea all the way to a shipped, delivered business. bm ai (the assistant at busymate.ai) guides the journey; it's backed by bm dev — the real-phone farm, the capture tooling, and MCP realtime — so every step is grounded in what real apps actually do.

One prompt starts the run, and a full run can span around 24 hours end to end. The Roadmap board is how you follow that run: each milestone is one phase of the pipeline, carrying a legible status so you always know what's live, what's being built, and what's still queued.

The 8-phase journey

The pipeline runs left to right — one idea in, a running business out:

Each milestone on the board expands the phase with a short description and evidence links you can click to see the backing capability:

1. Idea → Prompt. It starts with one prompt: you tell bm ai the idea, and the run begins — where, how, and when to start the startup.
2. Research & Audit. bm ai researches the market and audits the competition on real iOS and Android phones — devtools capture what competitor apps actually do on the wire. Capability live — the farm phones capture real competitor traffic today; a proven end-to-end autonomous research run is still pending.
3. Find the Gap. From the audit evidence, bm ai maps the competition's gap — your concrete opportunity.
4. Propose the Solution. A real, scoped proposal: the product shape, the differentiator, and the plan to build it.
5. Implement. The agent builds the product — code, content, and configuration — commit by commit, watchable as it happens.
6. Test On-Platform. The build is exercised on the real-phone farm — bm ai drives the devices over MCP, backed by devtools capture. Capability live — bm ai drives real devices over MCP today; a proven end-to-end autonomous test run is still pending.
7. Submit & Deliver. Submission to the stores and services, delivering the product to the customer's end users. In review, delivery not yet live — the iOS app's v1.0.1 submission is in App Review while the store still serves v1.0; the automated submit-to-store pipeline is not built yet.
8. Watch it LIVE. Live preview and MCP realtime widgets show the business running — plus a valuable artifact and the human + agent resources to start right away. Live but fragile — the native H.264 mirror re-establishes fragilely after a daemon recycle (re-verify pending); the MJPEG fallback keeps the stream up so nothing goes black.

The vision behind the pipeline is captured in the public North-Star artifact: busymate.ai/artifact/busymate-north-star.

How status works

Every phase carries one of three statuses, shown as a colored pill — the same token-driven palette the rest of the dashboard uses, so the color means the state, not decoration:

Some phases also carry an italic honesty caveat under their description — the nuance a three-value status can't: a live capability whose proven autonomous run is still pending, a fragile leg, or a store submission that's in review but not yet delivering. The board never over-claims — "live" means the capability is real today, and the caveat tells you exactly what's still owed.

A summary line at the top of the board rolls the phases up — e.g. 4 of 8 phases live · 4 building — so you can read where the journey stands at a glance, and it moves as each ship advances a phase.

Programs

Under the pipeline sits the program register — the named, finite bodies of work running inside the journey. A program makes one or more phases faster, truer, or possible at all, and then it ends; the eight-step pipeline never grows because a program has twelve phases. Each program card shows its title, a link to the owning epic issue, a link to the program document, a where-we-are summary, and one row per phase with the phase's tracked issue.

Today the register carries two programs:

Live phase state

A program phase's status is live, not hand-set. The reviewed config carries a floor — the report as of the last ship — and the board overlays it with the tracked issue's projected state on the WIP board (the single-writer projection of GitHub reality, fanned in realtime — no polling):

The overlay never reads below the floor, and a pill whose state came from the live board pulses while the phase is in flight. When an issue closes, its phase flips on the page the moment the board learns of it.

Reading the register elsewhere

GET https://dash.busymate.dev/api/roadmap (signed-in) returns the same register as JSON — the pipeline, and every program with its epic, document, and phases (id, title, issue, issue_url, floor_status) — so a client can join the mapping with the live issue rows the wip_list MCP tool already returns.

Following along

The Roadmap is a read-only board — it's the shared picture of where things are, not a place you edit. The status per phase is kept current with every ship that moves a phase forward — today it's a reviewed, hand-maintained config (deriving it live from tracked issues, to-dos, and farm state is the recorded follow-up), and the honesty caveats keep the board from over-claiming in the meantime.

You can jump straight from a milestone to the capability behind it — the Phone Farm, your Devices, the App Store status preview, or the developer consoles for the MCP tools bm ai drives. It sits alongside your To-dos and WIP boards as one of the dashboard's top-level destinations.