# Maker pack: build and package your own agents

> Maker is a meta-agent that designs, validates and packages new BMAD+ agents. Install command, the four creation phases, six prompts, the output folder and what the package is meant for.

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

BMAD+ documentation › [Packs](https://bmad-plus.rochetta.fr/docs/packs/) › Maker pack: build and package your own agents

Maker is an agent that creates other agents. You describe what you need, Maker walks you through the persona, the capabilities, the automatic activation triggers and the skills, shows you a design preview, and only then generates a package in the format BMAD+ expects. It is the pack for people who want a specialist that does not exist yet, such as a customer-support agent or a release-notes writer, written in the same shape as Atlas or Forge.

<a id="when-to-use"></a>
## When to use it

- You need a recurring specialist role with its own voice, rules and menu, not a one-off prompt.
- You want an existing agent file checked for format problems before you share it (code VA).
- You contribute agents to BMAD+ itself: the package comes with an integration guide for the source repository.

<a id="installed"></a>
## What is installed

One agent, Maker, in `.agents/skills/agent-maker/` (an instruction file and a manifest). The pack has no separate skills and no data file. Its menu:

**Maker menu**

| Code | Capability | What it asks or produces |
| --- | --- | --- |
| CA | Create Agent: full guided creation | Four phases: discovery, design with your validation, generation, validation |
| QA | Quick Agent | Two questions (what it does, name and icon), sensible defaults for the rest |
| EA | Edit Agent | Changes an existing agent’s `SKILL.md` in place |
| VA | Validate Agent | Checks format, manifest, unique capability codes and trigger quality |
| PA | Package Agent | Generates the integration-ready folder |
| TP | Show Template | Displays the BMAD+ agent template |

<a id="creation-phases"></a>
### The four phases of Create Agent

1. Discovery: one batch of five questions: what the agent does, which domain, whether it needs several roles, which tools or APIs it needs, which personality.
2. Design: a preview table (name, persona and icon, title, roles, pack name, capabilities with codes, triggers, dependencies). Nothing is generated until you approve; Maker iterates until you do.
3. Generation: the files listed in the outputs section below.
4. Validation: a self-check of the format, the manifest fields, the pack definition, the uniqueness of the two-letter codes and the integration guide, presented to you as a checklist.

<a id="quick-start"></a>
## Quick start

1. **Install the pack** Core is added automatically. Maker needs only Node.js 20 or newer for the installer.

   ```sh
   npx bmad-plus install --packs maker
   ```
2. **Call Maker with a description** The more precise the purpose, the fewer questions it has to ask.

   ```sh
   Maker, create a customer support agent.
   ```
3. **Review the design preview, then the package** Approve or correct the preview table. The package appears in `_bmad-output/ready-to-integrate/`.

<a id="examples"></a>
## Copyable examples

<a id="example-maker-create-agent"></a>
### Create an agent with the full guided flow (CA)

Use it when the agent needs several roles or tools and you want to control every choice.

**In your AI assistant**

```text
Maker, create a customer support agent. It should triage incoming tickets, draft replies in a calm tone and escalate billing disputes to a human. It needs read access to our help-centre articles. Two roles: Triage and Reply.
```

**What you should get** Maker asks its five discovery questions in a single batch (your request already answers several of them), then shows the design preview table and waits for approval. After approval it writes the package in `_bmad-output/ready-to-integrate/` and presents the validation checklist.

<a id="example-maker-quick-agent"></a>
### Create a small agent fast (QA)

Use it for a single-purpose agent. You can refine the result afterwards.

**In your AI assistant**

```text
Maker, quick agent: a release-notes writer named Chronicle that turns a list of merged changes into user-facing notes. Icon: a scroll.
```

**What you should get** Only the two questions are asked (purpose, name and icon); everything else gets sensible defaults. The same package files are generated, and you can then ask for edits.

<a id="example-maker-edit-agent"></a>
### Edit an existing agent (EA)

Point Maker at the folder of the agent and say what should change. Edit Agent works on the agent’s `SKILL.md` where it already is.

**In your AI assistant**

```text
Maker, edit the agent in _bmad-output/ready-to-integrate/agents/agent-chronicle: add a capability with code BR that drafts a breaking-changes section, and make the description in its front matter more specific so it is not picked for every request that merely mentions an update.
```

**What you should get** The agent’s `SKILL.md` is changed in place, in the folder you named, and Maker keeps the rule that capability codes stay unique. One of its principles is to validate with you before finalising, so expect a summary of the edit to confirm. The package has no separate triggers file: how the agent gets picked comes from the description in its front matter.

<a id="example-maker-validate-agent"></a>
### Validate an agent package (VA)

Use it before you share or contribute an agent, including one that was not made by Maker.

**In your AI assistant**

```text
Maker, validate this agent package: _bmad-output/ready-to-integrate/agents/agent-chronicle. List every problem and offer to fix each one.
```

**What you should get** A report on four points: `SKILL.md` format compliance, manifest completeness, uniqueness of capability codes and quality of the triggers (specific enough or not). Each issue comes with an offer to fix it. This reads files; it does not run the agent.

<a id="example-maker-package-agent"></a>
### Generate the integration-ready folder (PA)

Use it when the design is settled and you want the files in one place.

**In your AI assistant**

```text
Maker, package the Chronicle agent so I can hand the folder to a contributor.
```

**What you should get** The folder `_bmad-output/ready-to-integrate/` holds `agents/agent-chronicle/SKILL.md`, `agents/agent-chronicle/bmad-skill-manifest.yaml`, `pack-definition.yaml` and `INTEGRATION.md`.

<a id="example-maker-show-template"></a>
### See the agent template before you write one (TP)

Use it to learn the expected structure, or to write an agent by hand.

**In your AI assistant**

```text
Maker, show me the BMAD+ agent template.
```

**What you should get** The template of an agent `SKILL.md`: front matter with `name` and `description`, then the sections Overview, Identity, Communication Style, Principles, Capabilities (code, description, skill) and On Activation.

<a id="outputs"></a>
## What it writes and where

**Files of a generated package**

| File in `_bmad-output/ready-to-integrate/` | Purpose |
| --- | --- |
| `agents/agent-<name>/SKILL.md` | The agent: identity, style, principles, capabilities, activation |
| `agents/agent-<name>/bmad-skill-manifest.yaml` | Manifest: display name, title, icon, capabilities, role, pack |
| `pack-definition.yaml` | A ready-to-merge entry for the `packs:` table of registry.yaml (order, display name, icon, agents, personas, skills, install layout) |
| `INTEGRATION.md` | Steps to integrate the agent into the BMAD+ source |

<a id="data-and-prerequisites"></a>
## Data flows and prerequisites

Maker needs nothing beyond Core and Node.js 20 for the installer: no Python, no key, no network service of its own. Creating and packaging an agent write only into `_bmad-output/ready-to-integrate/`; Edit Agent changes the `SKILL.md` of an existing agent wherever you point it. The only data that leaves your machine is what your AI tool sends to its model, as with any other agent.

<a id="limits"></a>
## Limits and gotchas

> **Warning · The package targets the BMAD+ source, not your installed project** The generated INTEGRATION.md walks you through adding the agent to the BMAD+ source repository: copy the folder to `src/bmad-plus/agents/`, add the pack entry from `pack-definition.yaml` to `registry.yaml` (the single source of truth), add the help line to `src/bmad-plus/module-help.csv`, then run `npm run build` and `node tools/build/generate-adapters.js --adopt`, and finish with the drift checks (`npm run build:check`, `generate-adapters --check --adopt`, `npm run check:counts`). It is meant for contributing agents to BMAD+ itself; Maker does not register a new agent into a project that merely has BMAD+ installed.

> **Note · Validation is a reading of files** Maker’s checks cover format, fields and uniqueness. They do not prove that the new agent behaves well in practice; test it on a real task before you rely on it.

> **Note · Provenance** Maker was written by Laurent Rochetta, the author of BMAD+.

**See also**

- [All ten packs side by side](https://bmad-plus.rochetta.fr/docs/packs/packs-overview/)
- [How agents are activated](https://bmad-plus.rochetta.fr/docs/agents/agents-activation/)
- [Registry and skills](https://bmad-plus.rochetta.fr/docs/concepts/registry-and-skills/)

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

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