What is Dybs.it?
Dybs.it is a local-first desktop app for leading a hybrid team (you plus a set of AI coding agents) through a full, disciplined development workflow. It runs the BMad Method as its engine.
You are the agile lead. Dybs.it is the cockpit you lead from: every epic, every story, every phase laid out in front of you, each one a click away from running, and around that, the machinery a real team needs. A different AI agent for development than for review, if you want one. A record of every session. Your plan mirrored into the tool the rest of your team already opens.
Note: This page assumes nothing. If the workflow underneath is new to you, What is the BMad Method? explains the engine.
The problem it solves
Start with the job to be done, not the feature list. Ask the uncomfortable question first.
What happens when one person tries to run an AI-native workflow by hand?
They become the single point of coordination. The human holds the plan in their head. They remember which story is ready for dev and which one is stuck in review. They copy the right slash command into the right terminal, in the right order, for the right agent. They track which artifact fed which decision. They are the messenger, the router, and the memory. All at once.
That works for one story. It falls apart across an epic.
The velocity is real: AI agents ship work faster than a human can manually keep track of it. But the coordination stays manual, and the human turns into the bottleneck their own team is waiting on. The orchestrator spends their time being the loop instead of leading it.
Dybs.it's job is to take that coordination off your shoulders. It makes the whole method visible (every phase, every story, every artifact in one place) and one-click runnable, so launching the next step is a click, not a recalled incantation. You stay in the loop without being the loop.
What it isn't
Clearing up three things it's easy to mistake it for:
- Not an IDE. Your code editor stays your code editor. Dybs.it directs the workflow (which phase runs next, which agent, which artifact) and hands the actual coding to the coding agent you choose.
- Not a chat wrapper. It doesn't put a window around one conversation. It runs a multi-story, multi-agent workflow with the state, isolation and history that requires.
- Not a generic kanban tracker. It's native to the method's semantics. It knows the difference between a story moving to review and a code-review comment, because those are method concepts, not columns on a board.
Who it's for
Dybs.it is built for the engineer-solopreneur, the agile lead running a hybrid team.
You are someone who:
- Is fluent in AI and fluent in shipping, and already treats your coding agents like a team.
- Wants the discipline of real agile (epics, stories, sprints, reviews), not prompt-rolling.
- Would rather direct the work than hand-carry every status update between phases.
If you lead a hybrid team and want the method to feel like it has a home, this is for you.
What you can do in it
Dybs.it gives you one surface for the whole method. From the cockpit you can:
| Do this | In Dybs.it |
|---|---|
| See your project | Browse your epics and stories in Work and Stories as they move through the phases of the method. |
| Run the method | Launch BMad Method agents in an embedded Terminal, with your choice of LLM. |
| Read and edit artifacts | Open the PRD, architecture, story specs and more in the Documents view, with markdown rendering and automatic file versioning. |
| Work in isolation | Use the built-in Git client and per-story worktrees so each story develops on its own branch without stepping on the others. Next release. |
| Pick up where you left off | Resume past LLM work from Session History, recorded per story. |
Two of those deserve a closer look.
The embedded terminal is multi-LLM. When you launch a command, you choose the coding agent behind it, Claude Code, Codex CLI, Gemini CLI, Kimi 3, OpenCode, or any other coding agent that supports the method and runs in a terminal. The workflow stays the same; the agent behind it is yours to pick, and you can pick a different one for development than for review. A Command Palette (Cmd+K) puts those commands and navigation a keystroke away.
Worktrees are the default substrate. Every story develops in its own git worktree, so parallel work stays isolated and clean, Dybs.it manages the branch-and-worktree bookkeeping for you.
Next release: the Git client and per-story worktrees are not in the current build. They arrive together in the next one.
Tip: Clicking a story's current phase opens a terminal already running the matching BMad Method command. That is the one-click-runnable promise made concrete, the coordination the human used to do by hand.
The live views
The cockpit is a single-page app with a sidebar. Each entry is a view onto your project:
| View | What it shows |
|---|---|
| Work | Your epics and the stories under each, with their current phase. Called Epics in the current build. Next release. |
| Stories | Every story and where it sits in the story lifecycle. |
| Intake | New ideas and requests on their way into the plan. Next release. |
| Documents | The method's artifacts, PRD, architecture, story specs, rendered and editable. |
| Agents | The roster of BMad Method personas you can launch. |
| History | Past LLM sessions, per story, ready to resume. |
Alongside the views sit the Terminal, the Git client, and Settings, the working surfaces you drop into without leaving the app.
Local-first, and yours
Dybs.it runs on your machine. Your project's data (session history, phase history, intake state) lives under <project>/.dybs/, right next to your code. The method's artifacts live in your repo's _bmad-output/. Nothing about the method requires a server or an account.
To get going you'll want three things:
- Node.js (v18 or newer).
- An LLM CLI, at least one coding agent that supports the BMad Method (Claude Code, Codex CLI, Gemini CLI, Kimi 3, OpenCode, or another).
- A project with a
_bmad/directory for Dybs.it to read. If the method is not installed there yet,npx bmad-method installputs it in place. Next release: Getting Started does this for you, from an empty folder.
Note: Dybs.it is not publicly downloadable yet. Installation has the current state and what to have ready for when it lands.
The engine: the open BMad Method
Dybs.it runs on the BMad Method, the AI-native development workflow created by Brian Madison and released as 100% open source, built by practitioners who ship software every day. It is a real dependency, not a badge: the phases, the agents and the artifacts you work with in Dybs.it are the method's.
It is open, it stays open, and running it in Dybs.it costs nothing.
Open is free tier. Always.
Method by Brian Madison · bmadcode.com · github.com/bmad-code-org/BMAD-METHOD
Next steps
- What is the BMad Method?: the workflow underneath, phase by phase.
- Installation: get the app on your machine and open your first project.
See also: The method overview · The agents