# Pack Core : Atlas, Forge, Sentinel et Nexus
> Le pack de base obligatoire de BMAD+ : quatre agents de l’idée à la livraison relue, six compétences partagées, commande d’installation, huit consignes à copier, sorties et limites.
Canonical: https://bmad-plus.rochetta.fr/fr/docs/packs/core/
Language: fr
BMAD+ version: 0.23.1
Documentation reviewed: 2026-10-19
Author: Laurent Rochetta
License: MIT
Documentation BMAD+ › [Packs](https://bmad-plus.rochetta.fr/fr/docs/packs/) › Pack Core : Atlas, Forge, Sentinel et Nexus
Core est le pack de base de BMAD+ et le seul que l’on ne peut pas écarter : toute installation le contient. Il apporte quatre agents qui couvrent le chemin de l’idée à une livraison relue, six compétences qui portent les protocoles partagés et un fichier de données pour le changement automatique de rôle. Un agent est une persona dotée d’instructions écrites et d’un menu de capacités, que votre outil de codage IA charge ; vous l’appelez par son nom dans la conversation. Une compétence est un protocole réutilisable, par exemple le pipeline autopilot, qu’un agent ouvre quand il en a besoin.
## Quand l’utiliser
- Vous avez une idée et il vous faut un brief, un PRD (document d’exigences produit) ou une étude de marché : demandez à Atlas.
- Il vous faut une architecture, une story implémentée, un bug tracé ou une documentation rédigée : demandez à Forge.
- Vous voulez une revue qui confronte le code au comportement attendu, des tests, ou une recette jouée par une personne : demandez à Sentinel.
- Vous voulez planifier des sprints, piloter un projet entier par points de contrôle ou lancer des tâches indépendantes en parallèle : demandez à Nexus.
## Ce qui est installé
**Les quatre agents de Core, leurs rôles et leurs codes de menu**
| Agent | Rôles internes | Codes de menu |
| --- | --- | --- |
| Atlas (Strategist) | `Analyst`, `Product Manager` | BP, MR, DR, TR, CB, PR, CU, DP |
| Forge (Architect-Dev) | `Architect`, `Developer`, `Tech Writer` | CA, IR, DS, CR, QS, QD, DP |
| Sentinel (Quality) | `QA Engineer`, `UX Reviewer`, `Recette` | QA, CR, CU, RB, RR, RG |
| Nexus (Orchestrator) | `Scrum Master`, `Quick Flow`, `Autopilot Controller`, `Parallel Supervisor` | SP, CS, ES, ER, CC, SS, QS, QD, AP, PL |
Les codes de menu sont des raccourcis à taper dans la conversation après avoir appelé l’agent : par exemple Atlas PR pour le PRD, Forge CA pour l’architecture, Sentinel RG pour la porte d’acceptation, Nexus AP pour l’autopilot. Ce sont des raccourcis de conversation, pas des commandes de terminal. Des phrases ordinaires fonctionnent aussi : les agents acceptent un code, une ligne du menu ou une demande en langage naturel.
**Les six compétences de Core et le fichier de données**
| Nom | Ce qu’il fait | Ouvert par |
| --- | --- | --- |
| `bmad-plus-autopilot` | Déroule le pipeline Discovery, Build, Ship avec points de contrôle ; lance d’abord l’intake de chaque pack concerné. | Nexus (AP) |
| `bmad-plus-parallel` | Détecte les tâches indépendantes et les supervise : lancer, surveiller, suspendre, relancer, réallouer, escalader. | Nexus (PL) |
| `bmad-plus-swarm` | Protocole de modérateur pour un essaim de sous-agents sous budget (`panel`, `jury`, `fanout`). | Nexus, rôle Parallel Supervisor |
| `bmad-plus-intake` | Pose les questions d’un pack quelques-unes à la fois, enregistre les réponses, rédige le brief. | Tout pack qui déclare un intake ; Atelier ; autopilot |
| `bmad-plus-uat` | Transforme une livraison en recette humaine, lit le passage, classe les échecs, calcule la porte. | Sentinel (RB, RR, RG) ; autopilot |
| `bmad-plus-sync` | Vérifie les mises à jour publiées de BMAD+ dans un projet installé ; prépare des dossiers de preuves pour les mainteneurs. Aucune fusion automatique en amont. | Tout le monde ; les mainteneurs dans le dépôt source |
| `role-triggers.yaml` (données) | Les mots-clés, situations et signaux de raisonnement qui font passer un agent d’un rôle à l’autre. | Tous les agents si `auto_role_activation` vaut true |
## Démarrage rapide
1. **Installer** Lancez l’installateur dans le dossier de votre projet. Core est toujours inclus : on ne le liste jamais. L’assistant interactif vous fait choisir les outils IA et les packs facultatifs.
```sh
npx bmad-plus install
```
2. **Ou installer sans questions** Pour les scripts et la CI, nommez vous-même les packs et l’outil, et ajoutez `--yes`. Avec `--yes` et aucun outil détecté, aucun fichier d’adaptateur n’est écrit : passez donc `--tools`.
```sh
npx bmad-plus install --packs core --tools claude-code --yes
```
3. **Ouvrir l’assistant dans le même dossier** Redémarrez ou ouvrez l’outil IA dans ce projet pour qu’il lise `AGENTS.md` et son fichier d’adaptateur. Demandez ensuite le tableau des agents ; `bmad-help` est un message à l’assistant, pas une commande shell.
```sh
bmad-help
```
4. **Confier une tâche concrète à un agent** Commencez par Atlas pour une nouvelle idée, par Forge pour une modification de code existant. Atlas affiche d’abord son menu et attend ; si seul le menu revient, répondez avec l’idée ou un code de menu.
```sh
Atlas, aide-moi à définir une petite application de facturation pour indépendants. Pose-moi des questions sur les utilisateurs, identifie le premier parcours utile et rédige un brief avec des critères d’acceptation.
```
## Exemples à copier
### Atlas : de l’idée au brief
À utiliser en premier, avant tout code. Atlas travaille ici en rôle Product Manager. Atlas s’arrête à l’activation pour afficher son menu : si c’est tout ce que vous obtenez, répondez avec l’idée ou le code `CB`.
**Dans votre assistant IA**
```text
Atlas, aide-moi à définir une petite application de facturation pour indépendants. Pose-moi des questions sur les utilisateurs, identifie le premier parcours utile et rédige un brief avec des critères d’acceptation.
```
**Ce que vous devriez obtenir** Atlas pose ses questions puis rédige le brief (capacité `CB`) dans `_bmad-output/discovery/` ; le nom du fichier porte celui du projet, `product-brief-.md`. Relisez-le avant de demander quoi que ce soit à Forge.
### Atlas : analyse de marché (rôle Analyst)
À utiliser pour savoir si un marché mérite qu’on s’y engage. Les mots analyser et marché déclenchent d’eux-mêmes le rôle Analyst.
**Dans votre assistant IA**
```text
Atlas, analyse le marché des applications de prise de notes par IA. Compare les principales alternatives, nomme les besoins clients qu’elles laissent ouverts et indique les affirmations que tu n’as pas pu sourcer.
```
**Ce que vous devriez obtenir** Atlas affiche d’abord son menu, car il attend à l’activation ; renvoyez la demande si c’est tout ce qu’il fait. Il annonce ensuite le changement de rôle (« I’m switching to Analyst mode », avec la raison, puis « Say skip to stay in current mode »), puis lance la capacité d’étude de marché (code MR) : paysage concurrentiel et besoins clients. La consultation de sources en direct dépend de votre outil hôte.
### Forge : architecture à partir d’un brief validé
À utiliser une fois le brief ou le PRD relu. Forge travaille en rôle Architect.
**Dans votre assistant IA**
```text
Forge, propose une architecture pour l’application décrite dans le brief produit de _bmad-output/discovery/. Consigne chaque décision technique avec ses compromis et arrête-toi pour ma relecture avant tout code.
```
**Ce que vous devriez obtenir** Un document d’architecture guidé (capacité CA). Le livrable documenté est `_bmad-output/discovery/architecture.md`. En autopilot, le point de contrôle `architecture` attend votre accord à cet endroit.
### Forge : un petit changement avec un minimum de cérémonie
À utiliser pour un changement borné dans du code existant. `quick dev` est la capacité QD du menu de Forge ; les mots rapide, hotfix ou simple sont des déclencheurs du rôle Quick Flow de Nexus, qui lance la même capacité.
**Dans votre assistant IA**
```text
Forge, quick dev : ajoute un indicateur de chargement à la liste des factures. Garde le changement petit, lance les contrôles qui le couvrent et liste ce que tu n’as pas lancé.
```
**Ce que vous devriez obtenir** Le changement est fait dans le style du projet (capacité QD). Le rôle Developer de Forge relie chaque critère d’acceptation à un contrôle réellement exécuté, distingue contrôles échoués, ignorés et non lancés, et ne réinitialise, n’indexe ni ne commit sans votre demande.
### Sentinel : une revue appuyée sur des preuves de la CLI
À utiliser sur un changement terminé. Si la ligne de commande BMAD+ est installée, la revue laisse des fichiers scellés ; sinon c’est une revue simple.
**Dans votre assistant IA**
```text
Sentinel, relis ce changement par rapport aux critères d’acceptation. Si la CLI BMAD+ est disponible, scelle le périmètre avec bmad-plus review scope, cite le code de chaque constat, rends compte de chaque fichier sélectionné, puis rapporte la réponse de bmad-plus review gate.
```
**Ce que vous devriez obtenir** Des fichiers sous `_bmad-output/review//` (`scope.json`, `checklist.md`, puis `findings.json` et `coverage.json`). La porte répond incomplete, findings ou clean ; Sentinel rapporte ce mot sans le rehausser, et une revue interrompue n’est jamais déclarée clean.
### Sentinel : une recette qu’une personne peut jouer
À utiliser quand une version arrive sur votre environnement de test et que quelqu’un doit la vérifier à l’écran. Les mots recette, UAT ou « qu’est-ce que je dois vérifier » font passer Sentinel en rôle Recette.
**Dans votre assistant IA**
```text
Sentinel, écris la recette de cette livraison sur notre environnement de test. Une étape par geste, un fait vérifiable par ligne, les libellés d’écran cités depuis le code, et signale les étapes qui écrivent pour de vrai. Fabrique la page, puis donne-moi le lien, la durée et ce que je ne dois pas sauter.
```
**Ce que vous devriez obtenir** Une spécification de recette sous `_bmad-output/uat/specs/`, une page autonome sous `_bmad-output/uat/pages/`, puis le lien, la durée et les étapes qui écrivent. Ensuite, Sentinel lit le passage, classe chaque échec (product, recipe, data ou undecided) et calcule la porte ; un échec undecided garde la porte rouge.
### Nexus : planifier une première version avec les trois autres
À utiliser quand les utilisateurs et le problème sont décrits. Nexus agit en Scrum Master et délègue.
**Dans votre assistant IA**
```text
Nexus, planifie la première version utilisable de mon application de prise de rendez-vous. Demande à Atlas de cadrer le périmètre, à Forge de proposer l’implémentation minimale et à Sentinel de définir les contrôles d’acceptation. Liste les dépendances et arrête-toi à la revue du plan avant l’implémentation.
```
**Ce que vous devriez obtenir** Un plan priorisé avec une première story réduite et des points de revue explicites. Les fichiers viennent quand vous demandez les étapes suivantes : `ES` écrit `epics.md` dans `_bmad-output/discovery/`, `SP` le plan de sprint `sprint-status.yaml` et `CS` un fichier par story dans `_bmad-output/build/`.
### Nexus : l’autopilot de l’idée à la livraison, avec points de contrôle
À utiliser pour un projet entier quand vous acceptez de relire à chaque point de contrôle. Dites le mot autopilot, puis donnez l’idée.
**Dans votre assistant IA**
```text
autopilot. Le projet : un SaaS de facturation pour petites entreprises avec gestion des devis. Arrête-toi à chaque point de contrôle et dis-moi ce que tu attends que j’approuve.
```
**Ce que vous devriez obtenir** Avec les réglages par défaut, Nexus rencontre quatre points de contrôle. Il déroule Discovery (brainstorming, brief, PRD, spécification UX) et attend au PRD et à la spécification UX (`discovery`) ; Build (architecture, puis epics, plan de sprint et chaque story implémentée et testée) et attend à l’architecture (`architecture`), puis signale chaque story terminée sans s’arrêter (`story` vaut `notify_only` en mode autopilot, `require_approval` sinon) ; Ship (revue de code, revue UX, documentation, recette, rétrospective) et attend à la livraison finale (`delivery`). Les `checkpoints` de `_bmad/config.yaml` changent les arrêts bloquants.
## Ce qu’il écrit et où
**Dossiers et fichiers créés par les agents et compétences de Core**
| Chemin | Écrit par | Contenu |
| --- | --- | --- |
| `.agents/skills/`, `.agents/data/` | L’installateur | Agents, compétences et `role-triggers.yaml` |
| `_bmad/config.yaml` | L’installateur | Mode d’exécution, points de contrôle, réglages uat et swarm |
| `_bmad-output/discovery/` | Atlas, Forge, Nexus | Brief produit (`product-brief-.md`), PRD, architecture, epics |
| `_bmad-output/build/` | Nexus, Forge | État du sprint et un fichier par story |
| `_bmad-output/review//` | Sentinel, `bmad-plus review` | Périmètre, checklist, constats, couverture |
| `_bmad-output/uat/` | Sentinel, `bmad-plus uat` | Spécifications de recette, pages, résultats, triage |
| `.bmad-plus/nexus/runs/` | Nexus, `bmad-plus nexus` | Enregistrements durables de tâches et de tentatives |
| `.bmad-plus/swarm/runs/` | Nexus, `bmad-plus swarm` | Briefs, réponses et décompte d’une exécution d’essaim |
## Les réglages qui pilotent Core
L’installateur écrit `_bmad/config.yaml`. Ces clés décident de combien Nexus vous sollicite. `require_approval` s’arrête et vous attend, `notify_only` informe et continue, `auto` continue et journalise. Le fichier complet est décrit sur la page de configuration.
**Extrait de _bmad/config.yaml (les commentaires sont ajoutés ici)**
```yaml
execution_mode: manual # manual | autopilot | hybrid
auto_role_activation: true
parallel_execution: true
checkpoints:
discovery: require_approval
architecture: require_approval
story: require_approval # notify_only when execution_mode is autopilot
delivery: require_approval
```
## Flux de données et prérequis
- Prérequis : Node.js 20 ou plus récent pour l’installateur. Core n’exige ni Python, ni clé d’API, ni outil supplémentaire. Votre outil de codage IA fournit le modèle, les permissions et d’éventuels agents parallèles.
- BMAD+ n’a pas de télémétrie. Les commandes de Core qui peuvent envoyer des données hors de votre machine demandent toutes une action de votre part : `update-check` (désactivable avec `update-policy --mode off`), `update --latest` (sur demande), `nexus launch` et `nexus verify` (elles exécutent les commandes que vous avez déclarées dans un plan) et la page de recette de `uat` (servie sur 127.0.0.1 uniquement, sauf publication de votre part).
## Limites et pièges
> **Remarque · Les agents sont des instructions, pas des processus** Installer Core écrit des fichiers d’instructions. Rien ne tourne en arrière-plan et BMAD+ n’embarque aucun modèle. Les agents parallèles, la navigation et l’exécution de commandes n’existent que si votre outil hôte les fournit ; sinon Nexus exécute les tâches l’une après l’autre et le dit.
> **Attention · Aucun pack ne livre encore de pipeline** La compétence autopilot sait remplacer ses phases génériques par un pipeline que déclare un pack, mais en 0.23.0 aucun pack n’en déclare : l’autopilot suit donc toujours Discovery, Build et Ship. Même chose pour les essaims : le moteur existe, aucun pack ne livre de définition d’essaim.
> **Astuce · Core et Dev Studio peuvent coexister** Dev Studio a des personas qui recoupent Atlas, Forge, Sentinel et Nexus. Installez les deux si vous voulez : choisissez la persona dont vous voulez le workflow. Le pack Design va plus loin : une fois installé, ses règles gouvernent le design visuel et l’accessibilité, et la revue UX de Sentinel les lui cède.
**Voir aussi**
- [Les dix packs côte à côte](https://bmad-plus.rochetta.fr/fr/docs/packs/packs-overview/)
- [Comment les agents s’activent](https://bmad-plus.rochetta.fr/fr/docs/agents/agents-activation/)
- [Pack Dev Studio](https://bmad-plus.rochetta.fr/fr/docs/packs/dev-studio/)
- [Référence de la commande install](https://bmad-plus.rochetta.fr/fr/docs/reference/cli-install/)
- [Fichier de configuration](https://bmad-plus.rochetta.fr/fr/docs/reference/config-yaml/)
- [Recettes d’acceptation (uat)](https://bmad-plus.rochetta.fr/fr/docs/reference/cli-uat/)
[Documentation BMAD+](https://bmad-plus.rochetta.fr/fr/docs/) · [Packs](https://bmad-plus.rochetta.fr/fr/docs/packs/)
[Code sur GitHub](https://github.com/lrochetta/BMAD-PLUS)