Terminal & LLM Providers

The BMAD method is driven by conversational agents, and those agents run in a terminal. BMAD Board puts that terminal inside the app — so you never leave the visual cockpit to launch a command, and the terminal always knows which story, which command, and which coding agent you meant.

This page covers three things woven together: the embedded terminal, the LLM providers you can run BMAD commands with, and the Command Palette that launches them fast.

The embedded terminal

The terminal is a real terminal, built into the board. Under the hood it's xterm.js in the app window talking to node-pty in the background — a genuine pseudo-terminal, not a fake console. Anything you'd run in your own shell, you can run here.

It's designed to feel like a modern terminal you already know:

Warp-style. Clean, readable, built for long agent sessions rather than one-line commands.
Tabbed. Open several terminals at once — one per story, say — and switch between them. Each story's work can have its own tab.
Persistent. The terminal stays alive as you move between the Epics, Stories, and Documents views. Navigating away doesn't kill your running agent; the session keeps going in the background.

It's where BMAD agents run

You rarely type a /bmad-* command by hand. When you click a phase on a story card in the Stories view, the board opens a terminal with the right command already filled in for that story:

You click	The terminal runs
Backlog (○)	`/bmad-create-story`
Ready (◐) / In Progress (◑)	`/bmad-dev-story`
Review (◕)	`/bmad-code-review`

The command is built for the story you clicked — it carries the path to that story's spec file — and launched with your chosen provider. You review it and let it run. That's the whole loop from the implementation phase, driven from one click.

Multi-LLM providers

BMAD Board is deliberately model-agnostic. It doesn't ship a model — it launches your coding agent's CLI. You bring the agent; the board orchestrates it. Any LLM CLI that supports the BMAD method works — the board ships built-in support for these out of the box:

Provider	CLI	What it is
Claude Code	`claude`	Anthropic's coding-agent CLI — the reference experience, and the only provider that runs `/bmad-*` slash commands natively.
Codex CLI	`codex`	OpenAI's terminal coding agent.
Gemini CLI	`gemini`	Google's terminal coding agent.
Cursor	`cursor`	The Cursor editor. Opens files/projects in the IDE rather than running the dev→review loop in the terminal.
Aider	`aider`	An open-source, pair-programming CLI that edits your repo from the command line.
Open Code	`opencode`	An open-source terminal coding agent.

Note: Only Claude Code understands /bmad-* commands as-is. Codex CLI, Gemini CLI, Aider, and Open Code are prompt-translated runners — the board rewrites each command into a plain-language instruction for them (see below). Cursor is an editor, not a terminal agent, so it opens the story file in the IDE instead of running the cycle.

The providers above are the ones with first-class, built-in integration — not a ceiling. Because the BMAD method is CLI-agnostic, any coding agent that supports it works, as long as you can run it from a terminal — the board launches the agent's CLI in the embedded terminal. It simply ships tuned launch-and-translate support for the ones listed here.

How BMAD Board translates a command for your provider

A /bmad-* slash command is Claude Code's native language. The other CLIs don't speak it — so the board translates the command into a natural-language prompt before launching it. You click the same phase; the board adapts the wording to the agent you're running.

For example, clicking Ready launches /bmad-dev-story, which the board sends as:

Provider	What actually gets launched
Claude Code	`/bmad-dev-story <story-file>` (the slash command, verbatim)
Codex CLI	"Read the BMAD workflow and implement the story at `<story-file>`"
Gemini CLI	"Read the BMAD story spec and implement the story at `<story-file>`" (launched interactively so the session stays open)
Aider	"implement the story per `<story-file>`"
Open Code	"Implement the story according to the spec at `<story-file>`"
Cursor	opens `<story-file>` in the editor

The story's spec-file path travels with the command in every case, so whichever agent you run knows exactly which story to act on. Because translation is lossy, Claude Code — which runs the commands at native fidelity — is the default the board prefers when nothing else decides.

Picking a provider

You choose which coding agent runs your commands. The choice resolves through a small chain, most specific first:

A per-skill override, if you've set one (see below).
Your default provider, set in Settings.
Falling back to Claude Code when it's available, since it runs BMAD commands natively.

Per-skill provider override. You don't have to pick one agent for everything. BMAD Board lets you override the provider per skill — so you could, say, run /bmad-dev-story with Claude Code but hand /bmad-code-review to a different agent for a second opinion. Set these overrides where you configure providers; the board remembers them per project.

Tip: Start with one provider (Claude Code is the smoothest path) and add others later. Nothing forces you to install all six — the board only offers the agents you actually have.

Prerequisite: Whatever provider you pick, its CLI has to be on your PATH so the board can launch it. If clicking a phase reports the agent isn't found, confirm the CLI runs from your own shell first, then set it in Settings.

The Command Palette

For everything you'd rather not hunt through menus for, there's the Command Palette. Press:

Cmd + K

It opens a quick launcher for BMAD commands and navigation — jump to a view, or kick off a /bmad-* command without clicking through a story card. It's the keyboard-first path through the cockpit: think of it as the fast lane when you already know where you're going.