# Pack Core: Atlas, Forge, Sentinel y Nexus

> El pack base obligatorio de BMAD+: cuatro agentes de la idea a la entrega revisada, seis habilidades compartidas, instalación, ocho prompts para copiar, salidas y límites.

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

Documentación de BMAD+ › [Packs](https://bmad-plus.rochetta.fr/es/docs/packs/) › Pack Core: Atlas, Forge, Sentinel y Nexus

Core es el pack base de BMAD+ y el único que no se puede omitir: toda instalación lo incluye. Aporta cuatro agentes que cubren el camino de la idea a una entrega revisada, seis habilidades con los protocolos compartidos y un archivo de datos para el cambio automático de rol. Un agente es un perfil (persona) con instrucciones escritas y un menú de capacidades que tu herramienta de programación con IA carga; lo llamas por su nombre en el chat. Una habilidad es un protocolo reutilizable, por ejemplo el pipeline autopilot, que un agente abre cuando lo necesita.

<a id="when-to-use"></a>
## Cuándo usarlo

- Tienes una idea y necesitas un brief, un PRD (documento de requisitos de producto) o un estudio de mercado: pide a Atlas.
- Necesitas una arquitectura, una story implementada, un bug rastreado o documentación escrita: pide a Forge.
- Quieres una revisión que contraste el código con el comportamiento esperado, pruebas o una receta de aceptación (recette) recorrida por una persona: pide a Sentinel.
- Quieres planificar sprints, llevar un proyecto entero con puntos de control o lanzar tareas independientes en paralelo: pide a Nexus.

<a id="installed"></a>
## Qué se instala

**Los cuatro agentes de Core, sus roles y sus códigos de menú**

| Agente | Roles internos | Códigos de menú |
| --- | --- | --- |
| 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 |

Los códigos de menú son atajos que escribes en el chat tras llamar al agente, por ejemplo Atlas PR para el PRD, Forge CA para la arquitectura, Sentinel RG para la puerta de aceptación, Nexus AP para el autopilot. Son atajos de chat, no comandos de terminal. Las frases normales también funcionan: los agentes aceptan un código, una línea del menú o una petición en lenguaje natural.

**Las seis habilidades de Core y el archivo de datos**

| Nombre | Qué hace | La abre |
| --- | --- | --- |
| `bmad-plus-autopilot` | Ejecuta el pipeline Discovery, Build y Ship con puntos de control; antes lanza el intake de cada pack implicado. | Nexus (AP) |
| `bmad-plus-parallel` | Detecta tareas independientes y las supervisa: lanzar, vigilar, pausar, reiniciar, reasignar, escalar. | Nexus (PL) |
| `bmad-plus-swarm` | Protocolo de moderador para un enjambre de subagentes bajo presupuesto (`panel`, `jury`, `fanout`). | Nexus, rol Parallel Supervisor |
| `bmad-plus-intake` | Hace las preguntas de un pack de pocas en pocas, registra las respuestas y redacta el brief. | Cualquier pack que declare un intake; Atelier; autopilot |
| `bmad-plus-uat` | Convierte una entrega en una receta de aceptación humana, lee la ejecución, clasifica los fallos y calcula la puerta. | Sentinel (RB, RR, RG); autopilot |
| `bmad-plus-sync` | Comprueba las actualizaciones publicadas de BMAD+ en un proyecto instalado; prepara paquetes de evidencias para mantenedores. Sin fusión automática desde upstream. | Cualquiera; mantenedores en el repositorio fuente |
| `role-triggers.yaml` (datos) | Las palabras clave, situaciones y señales de razonamiento que cambian a un agente de rol. | Todos los agentes si `auto_role_activation` es true |

<a id="quick-start"></a>
## Inicio rápido

1. **Instalar** Ejecuta el instalador en la carpeta de tu proyecto. Core siempre se incluye, así que nunca lo indicas. En el asistente interactivo eliges las herramientas de IA y los packs opcionales.

   ```sh
   npx bmad-plus install
   ```
2. **O instalar sin preguntas** Para scripts y CI, indica tú los packs y la herramienta, y añade `--yes`. Con `--yes` y sin herramienta detectada no se escribe ningún adaptador, así que pasa `--tools`.

   ```sh
   npx bmad-plus install --packs core --tools claude-code --yes
   ```
3. **Abrir el asistente en la misma carpeta** Reinicia o abre la herramienta de IA en este proyecto para que lea `AGENTS.md` y su archivo de adaptador. Después pide la lista de agentes; `bmad-help` es un mensaje al asistente, no un comando de shell.

   ```sh
   bmad-help
   ```
4. **Dar una tarea concreta a un agente** Empieza con Atlas para una idea nueva y con Forge para un cambio en código existente. Atlas muestra primero su menú y espera; si solo vuelve el menú, responde con la idea o con un código de menú.

   ```sh
   Atlas, ayúdame a definir una pequeña aplicación de facturación para autónomos. Pregunta por los usuarios, identifica el primer flujo útil y redacta un brief con criterios de aceptación.
   ```

<a id="examples"></a>
## Ejemplos para copiar

<a id="example-core-atlas-brief"></a>
### Atlas: de la idea al brief

Úsalo primero, antes de que exista código. Atlas trabaja aquí como Product Manager. Atlas se detiene en la activación para mostrar su menú: si es lo único que recibes, responde con la idea o con el código `CB`.

**En tu asistente de IA**

```text
Atlas, ayúdame a definir una pequeña aplicación de facturación para autónomos. Pregunta por los usuarios, identifica el primer flujo útil y redacta un brief con criterios de aceptación.
```

**Lo que deberías obtener** Atlas hace sus preguntas y luego redacta el brief (capacidad `CB`) en `_bmad-output/discovery/`; el nombre del archivo lleva el del proyecto, `product-brief-<project>.md`. Revísalo antes de pedirle nada a Forge.

<a id="example-core-atlas-market"></a>
### Atlas: análisis de mercado (rol Analyst)

Úsalo para saber si merece la pena entrar en un mercado. Las palabras analizar y mercado activan por sí solas el rol Analyst.

**En tu asistente de IA**

```text
Atlas, analiza el mercado de las aplicaciones de notas con IA. Compara las principales alternativas, nombra las necesidades de cliente que dejan abiertas e indica qué afirmaciones no has podido respaldar con fuentes.
```

**Lo que deberías obtener** Atlas muestra primero su menú, porque espera en la activación; vuelve a enviar la petición si es lo único que hace. Después anuncia el cambio («I’m switching to Analyst mode», con el motivo, y «Say skip to stay in current mode»), y lanza la capacidad de estudio de mercado (código MR): panorama competitivo y necesidades de los clientes. Consultar fuentes en vivo depende de tu herramienta anfitriona.

<a id="example-core-forge-architecture"></a>
### Forge: arquitectura a partir de un brief aprobado

Úsalo cuando el brief o el PRD ya estén revisados. Forge trabaja como Architect.

**En tu asistente de IA**

```text
Forge, propón una arquitectura para la aplicación descrita en el brief de producto de _bmad-output/discovery/. Registra cada decisión técnica con sus compromisos y detente para mi revisión antes de escribir código.
```

**Lo que deberías obtener** Un documento de arquitectura guiado (capacidad CA). El entregable documentado es `_bmad-output/discovery/architecture.md`. En autopilot, el punto de control `architecture` espera tu aprobación aquí.

<a id="example-core-forge-quick-dev"></a>
### Forge: un cambio pequeño con mínima ceremonia

Úsalo para un cambio acotado en código existente. `quick dev` es la capacidad QD del menú de Forge; las palabras rápido, hotfix o simple son disparadores del rol Quick Flow de Nexus, que ejecuta la misma capacidad.

**En tu asistente de IA**

```text
Forge, quick dev: añade un indicador de carga a la lista de facturas. Mantén el cambio pequeño, ejecuta las comprobaciones que lo cubren y enumera lo que no ejecutaste.
```

**Lo que deberías obtener** El cambio se hace con el estilo del propio proyecto (capacidad QD). El rol Developer de Forge asocia cada criterio de aceptación con una comprobación realmente ejecutada, distingue las comprobaciones fallidas, omitidas y no ejecutadas, y no revierte, añade al índice ni hace commit si no se lo pides.

<a id="example-core-sentinel-review"></a>
### Sentinel: una revisión respaldada por evidencias de la CLI

Úsalo sobre un cambio terminado. Si la línea de comandos de BMAD+ está instalada, la revisión deja archivos sellados; si no, es una revisión simple.

**En tu asistente de IA**

```text
Sentinel, revisa este cambio frente a los criterios de aceptación. Si la CLI de BMAD+ está disponible, sella el alcance con bmad-plus review scope, cita el código de cada hallazgo, da cuenta de cada archivo seleccionado y comunica lo que responde bmad-plus review gate.
```

**Lo que deberías obtener** Archivos bajo `_bmad-output/review/<id>/` (`scope.json`, `checklist.md`, luego `findings.json` y `coverage.json`). La puerta responde incomplete, findings o clean; Sentinel comunica esa palabra sin mejorarla, y una revisión interrumpida nunca se declara clean.

<a id="example-core-sentinel-recette"></a>
### Sentinel: una receta de aceptación que una persona puede recorrer

Úsalo cuando una versión llega a tu entorno de pruebas y alguien debe comprobarla en pantalla. Las palabras recette, UAT o «what should I check» pasan a Sentinel a su rol Recette.

**En tu asistente de IA**

```text
Sentinel, escribe la receta de aceptación (recette) de esta entrega en nuestro entorno de pruebas. Un paso por gesto, un hecho verificable por línea, las etiquetas de pantalla citadas desde el código, y marca los pasos que escriben de verdad. Construye la página y dime el enlace, la duración y lo que no debo saltarme.
```

**Lo que deberías obtener** Una especificación de receta en `_bmad-output/uat/specs/`, una página autónoma en `_bmad-output/uat/pages/`, y después el enlace, la duración y los pasos que escriben. Más tarde, Sentinel lee la ejecución, clasifica cada fallo (product, recipe, data o undecided) y calcula la puerta; un fallo undecided mantiene la puerta en rojo.

<a id="example-core-nexus-plan"></a>
### Nexus: planificar una primera versión con los otros tres

Úsalo cuando ya están descritos los usuarios y el problema. Nexus actúa como Scrum Master y delega.

**En tu asistente de IA**

```text
Nexus, planifica la primera versión utilizable de mi aplicación de reserva de citas. Pide a Atlas que acote el alcance, a Forge que proponga la implementación mínima y a Sentinel que defina las comprobaciones de aceptación. Enumera las dependencias y detente en la revisión del plan antes de implementar.
```

**Lo que deberías obtener** Un plan priorizado con una primera story pequeña y puntos de revisión explícitos. Los archivos llegan cuando pides los pasos siguientes: `ES` escribe `epics.md` en `_bmad-output/discovery/`, `SP` el plan de sprint `sprint-status.yaml` y `CS` un archivo por story en `_bmad-output/build/`.

<a id="example-core-nexus-autopilot"></a>
### Nexus: autopilot de la idea a la entrega, con puntos de control

Úsalo para un proyecto completo cuando aceptas revisar en cada punto de control. Di la palabra autopilot y luego da la idea.

**En tu asistente de IA**

```text
autopilot. El proyecto: un SaaS de facturación para pequeñas empresas con gestión de presupuestos. Detente en cada punto de control y dime qué necesitas que apruebe.
```

**Lo que deberías obtener** Con los ajustes por defecto, Nexus se encuentra cuatro puntos de control. Ejecuta Discovery (brainstorming, brief, PRD, especificación UX) y espera en el PRD y la especificación UX (`discovery`); Build (arquitectura, luego epics, plan de sprint y cada story implementada y probada) y espera en la arquitectura (`architecture`), y después comunica cada story terminada sin detenerse (`story` es `notify_only` en modo autopilot y `require_approval` en los demás); Ship (revisión de código, revisión UX, documentación, receta de aceptación, retrospectiva) y espera en la entrega final (`delivery`). Los `checkpoints` de `_bmad/config.yaml` cambian qué paradas bloquean.

<a id="outputs"></a>
## Qué escribe y dónde

**Carpetas y archivos creados por los agentes y habilidades de Core**

| Ruta | Lo escribe | Contenido |
| --- | --- | --- |
| `.agents/skills/`, `.agents/data/` | El instalador | Agentes, habilidades y `role-triggers.yaml` |
| `_bmad/config.yaml` | El instalador | Modo de ejecución, puntos de control, ajustes de uat y swarm |
| `_bmad-output/discovery/` | Atlas, Forge, Nexus | Brief de producto (`product-brief-<project>.md`), PRD, arquitectura, epics |
| `_bmad-output/build/` | Nexus, Forge | Estado del sprint y un archivo por story |
| `_bmad-output/review/<id>/` | Sentinel, `bmad-plus review` | Alcance, checklist, hallazgos, cobertura |
| `_bmad-output/uat/` | Sentinel, `bmad-plus uat` | Especificaciones de receta, páginas, resultados, triaje |
| `.bmad-plus/nexus/runs/` | Nexus, `bmad-plus nexus` | Registros duraderos de tareas e intentos |
| `.bmad-plus/swarm/runs/` | Nexus, `bmad-plus swarm` | Briefs, respuestas y recuento de una ejecución de enjambre |

<a id="config"></a>
## Los ajustes que gobiernan Core

El instalador escribe `_bmad/config.yaml`. Estas claves deciden cuánto te consulta Nexus. `require_approval` se detiene y te espera, `notify_only` informa y continúa, `auto` continúa y deja registro. El archivo completo se describe en la página de configuración.

**Extracto de _bmad/config.yaml (los comentarios se añaden aquí)**

```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

```

<a id="data-and-prerequisites"></a>
## Flujos de datos y requisitos

- Requisito: Node.js 20 o superior para el instalador. Core no necesita Python, ni clave de API, ni herramientas adicionales. Tu herramienta de programación con IA aporta el modelo, los permisos y los posibles agentes paralelos.
- BMAD+ no tiene telemetría. Los comandos de Core que pueden enviar datos fuera de tu máquina exigen siempre una acción tuya: `update-check` (desactivable con `update-policy --mode off`), `update --latest` (voluntario), `nexus launch` y `nexus verify` (ejecutan los comandos que declaraste en un plan) y la página de aceptación de `uat` (servida solo en 127.0.0.1 salvo que la publiques tú).

<a id="limits"></a>
## Límites y trampas

> **Nota · Los agentes son instrucciones, no procesos** Instalar Core escribe archivos de instrucciones. Nada corre en segundo plano y BMAD+ no incluye ningún modelo. Los agentes paralelos, la navegación y la ejecución de comandos existen solo si tu herramienta anfitriona los ofrece; si no, Nexus ejecuta las tareas una tras otra y lo dice.

> **Advertencia · Ningún pack incluye aún un pipeline** La habilidad autopilot puede sustituir sus fases genéricas por un pipeline que declare un pack, pero en 0.23.0 ningún pack lo hace, así que el autopilot sigue siempre Discovery, Build y Ship. Con los enjambres pasa lo mismo: el motor existe y ningún pack incluye una definición de enjambre.

> **Consejo · Core y Dev Studio pueden convivir** Dev Studio tiene perfiles (personas) que se solapan con Atlas, Forge, Sentinel y Nexus. Instala ambos si quieres: elige el perfil cuyo workflow necesitas. El pack Design va más lejos: una vez instalado, sus reglas gobiernan el diseño visual y la accesibilidad, y la revisión UX de Sentinel se los cede.

**Véase también**

- [Los diez packs lado a lado](https://bmad-plus.rochetta.fr/es/docs/packs/packs-overview/)
- [Cómo se activan los agentes](https://bmad-plus.rochetta.fr/es/docs/agents/agents-activation/)
- [Pack Dev Studio](https://bmad-plus.rochetta.fr/es/docs/packs/dev-studio/)
- [Referencia del comando install](https://bmad-plus.rochetta.fr/es/docs/reference/cli-install/)
- [Archivo de configuración](https://bmad-plus.rochetta.fr/es/docs/reference/config-yaml/)
- [Recetas de aceptación (uat)](https://bmad-plus.rochetta.fr/es/docs/reference/cli-uat/)

[Documentación de BMAD+](https://bmad-plus.rochetta.fr/es/docs/) · [Packs](https://bmad-plus.rochetta.fr/es/docs/packs/)

[Código en GitHub](https://github.com/lrochetta/BMAD-PLUS)