# How agents are activated: names, roles, triggers and chat commands

> Call an agent by name, use menu codes, let roles switch through three trigger levels, and use the chat words bmad-help, autopilot and parallel. Includes what to check when an agent stays silent.

Canonical: https://bmad-plus.rochetta.fr/docs/agents/agents-activation/
Language: en
BMAD+ version: 0.23.1
Documentation reviewed: 2026-10-19
Author: Laurent Rochetta
License: MIT

BMAD+ documentation › [Agents](https://bmad-plus.rochetta.fr/docs/agents/) › How agents are activated: names, roles, triggers and chat commands

Installing BMAD+ writes the agents into your project; activating one is just talking to your AI coding tool. There is no process to start. You say an agent’s name, your tool loads that agent’s instructions, and the agent greets you and works. This page explains the ways to call an agent, how an agent changes role by itself (and how to stop it), what the chat words `bmad-help`, `autopilot` and `parallel` do, and what to check when nothing answers.

<a id="call-by-name"></a>
## Calling an agent

- By name, followed by the task: `Atlas, analyze the market for AI note-taking apps.` The name can come first in any sentence; a persona name works too (`Miriam`, `Oholiab`, `Atelier`).
- By menu code, after calling the agent: each agent shows a menu with two-letter codes (`PR` for a PRD with Atlas, `CA` for an architecture with Forge, `RG` for the acceptance gate with Sentinel, `AP` for autopilot with Nexus). A code, a line number or a close description all work, and the agent invokes the capability by its registered name rather than inventing one.
- By command word for the packs that define one: `/seo …` (SEO / GEO) and `/design …` (Design) are typed in the chat and routed by the pack’s skill; your tool does not register them as slash commands, so a plain request works as well. `/backup`, `/backup-list`, `/backup-restore` and `/backup-clean` are the four menu entries of the Backup Manager. The Animated pack has none: describe the job, for example `animated website from hero.mp4`.
- By Dev Studio workflow id: name the persona and the workflow (`Yosef, validate-prd on docs/prd.md`). Each workflow also answers to `bmad-<id>` and `bmad-plus-<id>`.

On first call an agent reads `_bmad/config.yaml` for your name, your communication language, the execution mode and the two switches below, loads a `project-context.md` and the role triggers if it finds them, greets you in your language and shows its menu. Atlas, Shadow and Maker then stop and wait for your choice; with them, state the task again or pick a menu code if only the menu comes back. Forge, Sentinel, Nexus and Atelier proceed when your request is already clear, as in the examples here, because a greeting is not a second confirmation; they wait for a selection only when you called them without a task.

<a id="example-agents-activation-by-name"></a>
### Call an agent with a clear task

The shortest form: name, comma, task.

**In your AI assistant**

```text
Forge, investigate why saving an edited invoice creates a duplicate. Reproduce the issue, trace the cause and propose the smallest fix.
```

**What you should get** Forge answers in your communication language and works as Developer or Architect depending on the wording. It reports the failure it reproduced, the cause and a focused fix, and keeps failed, skipped and unrun checks apart.

<a id="example-agents-activation-menu-code"></a>
### Use a menu code

Codes are per agent: the same two letters can mean different things for different agents (`CA` creates an architecture for Forge and an agent for Maker; `QA` generates tests for Sentinel and creates a quick agent for Maker).

**In your AI assistant**

```text
Sentinel, RG
```

**What you should get** Sentinel runs the capability behind `RG`: compute the acceptance gate of the human recipe and emit its verifier for Nexus. It answers passed, failed, awaiting or stale, with the reasons, and never marks an unperformed step as passed.

<a id="role-switching"></a>
## Roles and automatic switching

Most agents have several roles. Atlas is an Analyst and a Product Manager; Forge an Architect, a Developer and a Tech Writer; Sentinel a QA Engineer, a UX Reviewer and a Recette (human acceptance) role; Nexus a Scrum Master, a Quick Flow runner, an Autopilot Controller and a Parallel Supervisor. When `auto_role_activation` is true (the default), the agent switches role itself when the conversation fits another one, and it says so first: "I’m switching to [Role] mode — [reason]. Say skip to stay in current mode." Answer `skip` and it stays. You can also ask for a role explicitly.

<a id="three-levels"></a>
### The three trigger levels

**How a role is chosen**

| Level | Signal | Example |
| --- | --- | --- |
| 1, patterns | Keywords in your request | The word architecture sends Forge to its Architect role |
| 2, contexts | Situations detected during the work | A change touching more than five files (`multi_file_change_gt_5`) calls for the Architect role; a release candidate on a test environment calls for Sentinel’s Recette role |
| 3, reasoning | Discoveries made while executing | Coding exposes an architectural issue (`implementation_exposes_architectural_issue`), so the Architect role returns |

**Sample keywords per agent, from role-triggers.yaml**

| Agent | Default role | Roles and sample keywords |
| --- | --- | --- |
| Atlas | `pm` | `analyst`: `analyze`, `research`, `market`, `benchmark`, `SWOT`, `stakeholder`; `pm`: `PRD`, `product brief`, `roadmap`, `MVP`, `user story` |
| Forge | `dev` | `architect`: `architecture`, `API`, `schema`, `stack`, `database`, `migration`; `dev`: `implement`, `code`, `build`, `fix`, `refactor`; `tech-writer`: `document`, `README`, `changelog`, `mermaid` |
| Sentinel | `qa` | `qa`: `test`, `review`, `bug`, `edge case`, `coverage`; `ux-review`: `UX`, `responsive`, `accessibility`, `usability`; `uat`: `recette`, `UAT`, `acceptance test`, `what should I check` |
| Nexus | `scrum-master` | `scrum-master`: `sprint`, `story`, `backlog`, `epic`; `quick-flow`: `quick`, `hotfix`, `simple`, `patch`; `autopilot`: `autopilot`, `full pipeline`, `from scratch`; `parallel-supervisor`: `parallel`, `concurrent`, `batch` |
| SEO Scout, Chief, Judge | `seo-chief` | `seo-chief`: `SEO`, `SERP`, `meta tags`; `seo-scout`: `crawl`, `sitemap`, `robots.txt`, `core web vitals`; `seo-judge`: `E-E-A-T`, `PageSpeed`, `CrUX`, `quality gate` |
| Atelier | `design-engine` | `Atelier`, `/design`, `design tokens`, `maquette`, `wireframe`, `landing page`, `make it look good`, `accessibility`, `redesign` |

The keywords include French and English words (for example "recherche", "marché", "rapide", "refonte"), so a request in either language triggers the same roles. The full lists live in `.agents/data/role-triggers.yaml`, which you can read. Note that the file lists Atlas’s default as Product Manager, while Atlas’s own instructions call Analyst the default for research and discovery.

<a id="example-agents-activation-auto-role-skip"></a>
### See an automatic role switch, and refuse it

Start in Atlas’s default role (Product Manager in `role-triggers.yaml`), then use a research word. The switch is announced before it happens.

**In your AI assistant**

```text
Atlas, benchmark our pricing against the three main competitors and run a SWOT on each.
```

**What you should get** Atlas greets you and shows its menu first, because it waits at activation; send the request again if only the menu comes back. The words benchmark and SWOT match the Analyst patterns, so Atlas announces the switch to Analyst mode with its reason and offers to stay in the current mode if you reply skip. If you reply skip, it continues as Product Manager and the analysis is framed accordingly.

<a id="example-agents-activation-explicit-role"></a>
### Ask for a role explicitly

Useful when you want a role the wording would not trigger, or when automatic switching is off.

**In your AI assistant**

```text
Sentinel, switch to your UX Reviewer role and review the checkout flow for keyboard access and error states.
```

**What you should get** Sentinel works as UX Reviewer for the whole answer. If the Design pack is installed, the visual-design and accessibility judgement belongs to Atelier, and Sentinel hands those points over.

**To stop automatic switching, set it to false in _bmad/config.yaml**

```yaml
auto_role_activation: false

```

<a id="chat-words"></a>
## The chat words: bmad-help, autopilot, parallel

Three phrases are instructions to your assistant, not terminal commands. Typing them in a shell does nothing.

**Chat words**

| Say | Effect |
| --- | --- |
| `bmad-help` | Shows the installed agents and workflows and recommends a next step. With Dev Studio it is also a workflow of Miriam. |
| `autopilot` | Launches Nexus in full-pipeline mode: Discovery, Build and Ship with checkpoints, after the intake of every pack involved. |
| `parallel` | Asks Nexus to detect independent tasks and supervise them in parallel; real parallelism depends on your host tool. |

<a id="example-agents-activation-autopilot"></a>
### Hand a whole project to Nexus

Which stops wait for you is set by `checkpoints` in `_bmad/config.yaml`. The `execution_mode` value sets the starting role of Nexus: manual starts it as Scrum Master, autopilot as Autopilot Controller; hybrid has no starting role of its own.

**In your AI assistant**

```text
autopilot. The project: a customer portal where clients download their invoices and open support tickets. Stop at the PRD and at the architecture.
```

**What you should get** Nexus becomes the Autopilot Controller and runs the pipeline: Discovery with Atlas (and Sentinel’s UX spec), a checkpoint at the PRD, Build with Forge, a checkpoint at the architecture, then stories, tests and Ship. With `execution_mode: autopilot` it announces that autopilot is active. With the default `checkpoints`, two more stops apply: each completed story is only reported (`story` is `notify_only` in autopilot mode) and the final delivery waits for your approval (`delivery`).

<a id="example-agents-activation-parallel"></a>
### Split independent work

Independent stories that share no file can run in parallel; dependent ones, same-file edits, architecture before code and review before merge stay sequential.

**In your AI assistant**

```text
Nexus, split the approved work into independent tasks. Give each role a scope, owned files and a definition of done. Use parallel agents only if this host supports them; otherwise run the tasks sequentially. Integrate the results and have Sentinel check the whole user flow.
```

**What you should get** Bounded assignments, explicit dependencies and one integrated review. Parallel execution comes from the host tool; when it cannot create independent agents, Nexus says so and works through the tasks one by one. For a durable record of attempts and independent checks, Nexus can use `bmad-plus nexus`.

<a id="execution-modes"></a>
## Execution mode and checkpoints

**Settings that shape activation**

| Key in _bmad/config.yaml | Values | Effect |
| --- | --- | --- |
| `execution_mode` | `manual`, `autopilot`, `hybrid` | Manual: you call the agents. Autopilot: Nexus manages the pipeline. Hybrid: offered by the installer as autopilot with frequent checkpoints; Nexus’s instructions define no behaviour for it beyond the `checkpoints` values. Set at install with `--mode`; only autopilot sets `story` to `notify_only`, the other modes ask for approval there too. |
| `auto_role_activation` | `true`, `false` | Whether agents switch roles by themselves. |
| `parallel_execution` | `true`, `false` | Whether Nexus may run independent tasks in parallel. |
| `checkpoints` | `discovery`, `architecture`, `story`, `delivery`: `require_approval`, `notify_only`, `auto` | Whether each stage stops for your approval, only reports, or continues and logs. |

<a id="cohabitation"></a>
## When two agents could answer

- Core and Dev Studio overlap (Atlas and Miriam, Forge and Bezalel, Sentinel and Oholiab, Nexus and Oholiab for sprints). Both can coexist; the one you name is the one that answers.
- Design overlaps Sentinel’s UX review and Rachel. Its trigger words are deliberately narrow (Atelier, /design, design tokens, maquette, wireframe, landing page, make it look good, accessibility, redesign): the bare words design, UI and interface still belong to Forge’s Architect role and Sentinel’s UX review. When Design is installed, its rules govern visual design and accessibility.
- The SEO agents (Scout, Chief, Judge) have their own trigger words and also route `/seo` command words.

<a id="not-responding"></a>
## When an agent does not answer

1. **Open the assistant in the installed project** The tool must run in the folder where BMAD+ was installed, so it can load `AGENTS.md` and its adapter file (for example `CLAUDE.md` or `GEMINI.md`).
2. **Check that the files exist** You need `AGENTS.md` at the project root and the folder `.agents/skills/`. If an adapter was not chosen at install, re-run the install with `--tools`.

   ```sh
   npx bmad-plus install --tools claude-code --yes
   ```
3. **Restart the session** Many tools read project instructions at session start only. Open a new session, then say the agent’s name again.
4. **Run the diagnostic** It checks the installation and names missing or modified files.

   ```sh
   npx bmad-plus doctor
   ```

> **Note · What activation does not do** An agent is a set of instructions that your tool follows. Nothing runs in the background, there is no scheduler, and parallel agents, browsing and command execution exist only if your host tool provides them. Permissions and the model come from that tool.

**See also**

- [Roster of all 48 agents](https://bmad-plus.rochetta.fr/docs/agents/agents-roster/)
- [Core pack](https://bmad-plus.rochetta.fr/docs/packs/core/)
- [Configuration file](https://bmad-plus.rochetta.fr/docs/reference/config-yaml/)
- [Supported tools and adapters](https://bmad-plus.rochetta.fr/docs/reference/adapters/)
- [Nexus and orchestration](https://bmad-plus.rochetta.fr/docs/concepts/nexus-orchestration/)
- [Troubleshooting](https://bmad-plus.rochetta.fr/docs/faq/troubleshooting/)

[BMAD+ documentation](https://bmad-plus.rochetta.fr/docs/) · [Agents](https://bmad-plus.rochetta.fr/docs/agents/)

[Source on GitHub](https://github.com/lrochetta/BMAD-PLUS)