# Core-Pack: Atlas, Forge, Sentinel und Nexus

> Das verpflichtende Basis-Pack von BMAD+: vier Agenten von der Idee bis zur geprüften Lieferung, sechs gemeinsame Skills, Installation, acht Prompts zum Kopieren, Ausgaben, Grenzen.

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

BMAD+ Dokumentation › [Packs](https://bmad-plus.rochetta.fr/de/docs/packs/) › Core-Pack: Atlas, Forge, Sentinel und Nexus

Core ist das Basis-Pack von BMAD+ und das einzige, das du nicht weglassen kannst: Jede Installation enthält es. Es liefert vier Agenten, die den Weg von der Idee bis zur geprüften Lieferung abdecken, sechs Skills mit den gemeinsamen Protokollen und eine Datendatei für den automatischen Rollenwechsel. Ein Agent ist eine Persona mit schriftlichen Anweisungen und einem Menü von Fähigkeiten, die dein KI-Coding-Werkzeug lädt; du rufst ihn im Chat beim Namen. Ein Skill ist ein wiederverwendbares Protokoll, etwa die Autopilot-Pipeline, das ein Agent bei Bedarf öffnet.

<a id="when-to-use"></a>
## Wann du es brauchst

- Du hast eine Idee und brauchst ein Briefing, ein PRD (Produktanforderungsdokument) oder eine Marktanalyse: frag Atlas.
- Du brauchst eine Architektur, eine umgesetzte Story, einen verfolgten Bug oder geschriebene Dokumentation: frag Forge.
- Du willst eine Prüfung, die den Code gegen das erwartete Verhalten abgleicht, Tests oder einen von einer Person durchgespielten Abnahmelauf (Recette): frag Sentinel.
- Du willst Sprints planen, ein ganzes Projekt über Checkpoints steuern oder unabhängige Aufgaben parallel laufen lassen: frag Nexus.

<a id="installed"></a>
## Was installiert wird

**Die vier Core-Agenten, ihre Rollen und ihre Menücodes**

| Agent | Rollen im Inneren | Menücodes |
| --- | --- | --- |
| 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 |

Die Menücodes sind Kürzel, die du nach dem Aufruf des Agenten im Chat tippst, zum Beispiel Atlas PR für das PRD, Forge CA für die Architektur, Sentinel RG für das Abnahme-Gate, Nexus AP für den Autopilot. Es sind Chat-Kürzel, keine Terminalbefehle. Ganz normale Sätze funktionieren genauso: Die Agenten nehmen einen Code, eine Menüzeile oder eine freie Anfrage an.

**Die sechs Core-Skills und die Datendatei**

| Name | Was er tut | Geöffnet von |
| --- | --- | --- |
| `bmad-plus-autopilot` | Führt die Pipeline Discovery, Build, Ship mit Checkpoints aus; startet zuerst den Intake jedes beteiligten Packs. | Nexus (AP) |
| `bmad-plus-parallel` | Erkennt unabhängige Aufgaben und überwacht sie: starten, beobachten, pausieren, neu starten, umverteilen, eskalieren. | Nexus (PL) |
| `bmad-plus-swarm` | Moderatorprotokoll für einen Schwarm von Sub-Agenten mit Budget (`panel`, `jury`, `fanout`). | Nexus, Rolle Parallel Supervisor |
| `bmad-plus-intake` | Stellt die Fragen eines Packs in kleinen Gruppen, hält Antworten fest und erzeugt das Briefing. | Jedes Pack mit Intake; Atelier; Autopilot |
| `bmad-plus-uat` | Macht aus einer Lieferung ein menschliches Abnahmeprotokoll, liest den Lauf, ordnet Fehler ein und berechnet das Gate. | Sentinel (RB, RR, RG); Autopilot |
| `bmad-plus-sync` | Prüft veröffentlichte BMAD+-Updates in einem installierten Projekt; bereitet Nachweispakete für Maintainer vor. Kein automatisches Upstream-Merge. | Alle; Maintainer im Quell-Checkout |
| `role-triggers.yaml` (Daten) | Die Stichwörter, Situationen und Denksignale, die einen Agenten zwischen seinen Rollen wechseln lassen. | Alle Agenten, wenn `auto_role_activation` true ist |

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

1. **Installieren** Starte den Installer im Ordner deines Projekts. Core ist immer dabei, du nennst es nie. Im interaktiven Assistenten wählst du die KI-Werkzeuge und optionale Packs.

   ```sh
   npx bmad-plus install
   ```
2. **Oder ohne Rückfragen installieren** Für Skripte und CI nennst du Packs und Werkzeug selbst und hängst `--yes` an. Mit `--yes` und ohne erkanntes Werkzeug wird keine Adapterdatei geschrieben, übergib also `--tools`.

   ```sh
   npx bmad-plus install --packs core --tools claude-code --yes
   ```
3. **Den Assistenten im selben Ordner öffnen** Starte das KI-Werkzeug in diesem Projekt neu oder öffne es, damit es `AGENTS.md` und seine Adapterdatei liest. Frag dann nach der Agentenliste; `bmad-help` ist eine Nachricht an den Assistenten, kein Shell-Befehl.

   ```sh
   bmad-help
   ```
4. **Einem Agenten eine konkrete Aufgabe geben** Beginne mit Atlas bei einer neuen Idee, mit Forge bei einer Änderung an bestehendem Code. Atlas zeigt zuerst sein Menü und wartet; kommt nur das Menü zurück, antworte mit der Idee oder einem Menücode.

   ```sh
   Atlas, hilf mir, eine kleine Rechnungs-App für Freiberufler zu definieren. Frag nach den Nutzern, bestimme den ersten nützlichen Ablauf und schreibe ein Briefing mit Akzeptanzkriterien.
   ```

<a id="examples"></a>
## Beispiele zum Kopieren

<a id="example-core-atlas-brief"></a>
### Atlas: von der Idee zum Briefing

Nutze es zuerst, bevor es Code gibt. Atlas arbeitet hier als Product Manager. Atlas hält bei der Aktivierung an, um sein Menü zu zeigen: Ist das alles, was du bekommst, antworte mit der Idee oder dem Code `CB`.

**In deinem KI-Assistenten**

```text
Atlas, hilf mir, eine kleine Rechnungs-App für Freiberufler zu definieren. Frag nach den Nutzern, bestimme den ersten nützlichen Ablauf und schreibe ein Briefing mit Akzeptanzkriterien.
```

**Das solltest du erhalten** Atlas stellt seine Fragen und schreibt dann das Briefing (Fähigkeit `CB`) nach `_bmad-output/discovery/`; der Dateiname enthält den Projektnamen, `product-brief-<project>.md`. Lies es, bevor du Forge etwas bauen lässt.

<a id="example-core-atlas-market"></a>
### Atlas: Marktanalyse (Rolle Analyst)

Nutze es, um zu klären, ob sich ein Markt lohnt. Die Wörter analysieren und Markt lösen die Analyst-Rolle von selbst aus.

**In deinem KI-Assistenten**

```text
Atlas, analysiere den Markt für KI-Notiz-Apps. Vergleiche die wichtigsten Alternativen, nenne die Kundenbedürfnisse, die sie offenlassen, und sag, welche Aussagen du nicht belegen konntest.
```

**Das solltest du erhalten** Atlas zeigt zuerst sein Menü, da er bei der Aktivierung wartet; sende die Anfrage erneut, falls das alles ist. Anschließend kündigt er den Wechsel an („I’m switching to Analyst mode“ mit Begründung und „Say skip to stay in current mode“) und startet dann die Marktforschungsfähigkeit (Code MR): Wettbewerbslage und Kundenbedürfnisse. Ob Live-Quellen abgefragt werden können, hängt von deinem Host-Werkzeug ab.

<a id="example-core-forge-architecture"></a>
### Forge: Architektur aus einem freigegebenen Briefing

Nutze es, wenn Briefing oder PRD geprüft sind. Forge arbeitet als Architect.

**In deinem KI-Assistenten**

```text
Forge, schlage eine Architektur für die App aus dem Produkt-Briefing in _bmad-output/discovery/ vor. Halte jede technische Entscheidung mit ihren Abwägungen fest und halte zur Prüfung an, bevor Code entsteht.
```

**Das solltest du erhalten** Ein geführtes Architekturdokument (Fähigkeit CA). Das dokumentierte Ergebnis ist `_bmad-output/discovery/architecture.md`. Im Autopilot wartet hier der Checkpoint `architecture` auf deine Freigabe.

<a id="example-core-forge-quick-dev"></a>
### Forge: eine kleine Änderung mit minimalem Aufwand

Nutze es für eine begrenzte Änderung an bestehendem Code. `quick dev` ist die Fähigkeit QD im Menü von Forge; die Wörter schnell, Hotfix oder einfach sind Trigger der Quick-Flow-Rolle von Nexus, die dieselbe Fähigkeit ausführt.

**In deinem KI-Assistenten**

```text
Forge, quick dev: füge der Rechnungsliste einen Ladeindikator hinzu. Halte die Änderung klein, führe die passenden Prüfungen aus und liste auf, was du nicht ausgeführt hast.
```

**Das solltest du erhalten** Die Änderung entsteht im Stil des Projekts (Fähigkeit QD). Forges Developer-Rolle ordnet jedes Akzeptanzkriterium einer tatsächlich ausgeführten Prüfung zu, trennt fehlgeschlagene, übersprungene und nicht ausgeführte Prüfungen und setzt nichts zurück, staged oder committet nichts, solange du es nicht verlangst.

<a id="example-core-sentinel-review"></a>
### Sentinel: eine Prüfung mit Belegen aus der CLI

Nutze es bei einer fertigen Änderung. Ist die BMAD+-Kommandozeile installiert, hinterlässt die Prüfung versiegelte Dateien; sonst ist es eine einfache Prüfung.

**In deinem KI-Assistenten**

```text
Sentinel, prüfe diese Änderung gegen die Akzeptanzkriterien. Falls die BMAD+-CLI verfügbar ist, versiegle den Umfang mit bmad-plus review scope, zitiere zu jedem Befund den Code, weise jede ausgewählte Datei aus und berichte, was bmad-plus review gate antwortet.
```

**Das solltest du erhalten** Dateien unter `_bmad-output/review/<id>/` (`scope.json`, `checklist.md`, dann `findings.json` und `coverage.json`). Das Gate antwortet incomplete, findings oder clean; Sentinel meldet dieses Wort ohne Aufwertung, und eine abgebrochene Prüfung wird nie clean genannt.

<a id="example-core-sentinel-recette"></a>
### Sentinel: ein Abnahmeprotokoll, das eine Person durchspielen kann

Nutze es, wenn eine Version in deiner Testumgebung ankommt und jemand sie am Bildschirm prüfen muss. Die Wörter Recette, UAT oder „what should I check“ schalten Sentinel in die Recette-Rolle.

**In deinem KI-Assistenten**

```text
Sentinel, schreibe das Abnahmeprotokoll (Recette) für diese Lieferung in unserer Testumgebung. Ein Schritt pro Handgriff, eine prüfbare Tatsache pro Zeile, Bildschirmbeschriftungen aus dem Code zitiert, und kennzeichne die Schritte, die wirklich schreiben. Baue die Seite und nenne mir den Link, die Dauer und was ich nicht überspringen darf.
```

**Das solltest du erhalten** Eine Protokollspezifikation unter `_bmad-output/uat/specs/`, eine eigenständige Seite unter `_bmad-output/uat/pages/`, dann Link, Dauer und die schreibenden Schritte. Später liest Sentinel den Lauf, ordnet jeden Fehler ein (product, recipe, data oder undecided) und berechnet das Gate; ein Fehler als undecided hält das Gate rot.

<a id="example-core-nexus-plan"></a>
### Nexus: eine erste Version mit den anderen dreien planen

Nutze es, wenn Nutzer und Problem beschrieben sind. Nexus handelt als Scrum Master und delegiert.

**In deinem KI-Assistenten**

```text
Nexus, plane die erste nutzbare Version meiner Terminbuchungs-App. Lass Atlas den Umfang festlegen, Forge die kleinste Umsetzung vorschlagen und Sentinel die Abnahmeprüfungen definieren. Liste die Abhängigkeiten auf und halte bei der Planprüfung vor der Umsetzung an.
```

**Das solltest du erhalten** Ein priorisierter Plan mit einer kleinen ersten Story und klaren Prüfpunkten. Dateien entstehen, wenn du die nächsten Schritte anfragst: `ES` schreibt `epics.md` nach `_bmad-output/discovery/`, `SP` den Sprintplan `sprint-status.yaml` und `CS` eine Datei pro Story nach `_bmad-output/build/`.

<a id="example-core-nexus-autopilot"></a>
### Nexus: Autopilot von der Idee bis zur Lieferung, mit Checkpoints

Nutze es für ein ganzes Projekt, wenn du an jedem Checkpoint prüfen willst. Sag das Wort autopilot und nenne dann die Idee.

**In deinem KI-Assistenten**

```text
autopilot. Das Projekt: ein Abrechnungs-SaaS für kleine Unternehmen mit Angebotsverwaltung. Halte an jedem Checkpoint an und sag mir, was ich freigeben soll.
```

**Das solltest du erhalten** Mit den Standardeinstellungen trifft Nexus auf vier Checkpoints. Es führt Discovery aus (Brainstorming, Briefing, PRD, UX-Spezifikation) und wartet beim PRD und bei der UX-Spezifikation (`discovery`); Build (Architektur, dann Epics, Sprintplan und jede Story umgesetzt und getestet) und wartet bei der Architektur (`architecture`), meldet danach jede fertige Story, ohne anzuhalten (`story` ist im Autopilot-Modus `notify_only`, sonst `require_approval`); Ship (Code-Review, UX-Review, Dokumentation, Abnahmeprotokoll, Retrospektive) und wartet bei der Endlieferung (`delivery`). Die `checkpoints` in `_bmad/config.yaml` ändern, welche Halte blockieren.

<a id="outputs"></a>
## Was es schreibt und wo

**Ordner und Dateien, die Core-Agenten und -Skills anlegen**

| Pfad | Geschrieben von | Inhalt |
| --- | --- | --- |
| `.agents/skills/`, `.agents/data/` | Der Installer | Agenten, Skills und `role-triggers.yaml` |
| `_bmad/config.yaml` | Der Installer | Ausführungsmodus, Checkpoints, uat- und swarm-Einstellungen |
| `_bmad-output/discovery/` | Atlas, Forge, Nexus | Produkt-Briefing (`product-brief-<project>.md`), PRD, Architektur, Epics |
| `_bmad-output/build/` | Nexus, Forge | Sprint-Status und eine Datei pro Story |
| `_bmad-output/review/<id>/` | Sentinel, `bmad-plus review` | Umfang, Checkliste, Befunde, Abdeckung |
| `_bmad-output/uat/` | Sentinel, `bmad-plus uat` | Protokollspezifikationen, Seiten, Ergebnisse, Triage |
| `.bmad-plus/nexus/runs/` | Nexus, `bmad-plus nexus` | Dauerhafte Aufgaben- und Versuchsprotokolle |
| `.bmad-plus/swarm/runs/` | Nexus, `bmad-plus swarm` | Briefings, Antworten und Auszählung eines Schwarm-Laufs |

<a id="config"></a>
## Die Einstellungen, die Core steuern

Der Installer schreibt `_bmad/config.yaml`. Diese Schlüssel bestimmen, wie oft Nexus dich fragt. `require_approval` hält an und wartet auf dich, `notify_only` meldet und macht weiter, `auto` macht weiter und protokolliert. Die vollständige Datei steht auf der Konfigurationsseite.

**Auszug aus _bmad/config.yaml (die Kommentare sind hier ergänzt)**

```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>
## Datenflüsse und Voraussetzungen

- Voraussetzung: Node.js 20 oder neuer für den Installer. Core braucht kein Python, keinen API-Schlüssel und keine zusätzlichen Werkzeuge. Dein KI-Coding-Werkzeug liefert Modell, Berechtigungen und eventuelle parallele Agenten.
- BMAD+ hat keine Telemetrie. Die Core-Befehle, die Daten von deinem Rechner senden können, brauchen alle eine Aktion von dir: `update-check` (abschaltbar mit `update-policy --mode off`), `update --latest` (auf Wunsch), `nexus launch` und `nexus verify` (sie führen die Befehle aus, die du in einem Plan deklariert hast) und die Abnahmeseite von `uat` (nur auf 127.0.0.1, außer du veröffentlichst sie selbst).

<a id="limits"></a>
## Grenzen und Stolpersteine

> **Hinweis · Agenten sind Anweisungen, keine Prozesse** Die Installation von Core schreibt Anweisungsdateien. Im Hintergrund läuft nichts, und BMAD+ bringt kein Modell mit. Parallele Agenten, Browsen und Befehlsausführung gibt es nur, wenn dein Host-Werkzeug sie bietet; sonst führt Nexus die Aufgaben nacheinander aus und sagt das.

> **Warnung · Noch liefert kein Pack eine Pipeline** Der Autopilot kann seine generischen Phasen durch eine von einem Pack deklarierte Pipeline ersetzen, aber in 0.23.0 deklariert keines eine; der Autopilot folgt also immer Discovery, Build und Ship. Bei Schwärmen ist es genauso: Die Laufzeit existiert, doch kein Pack liefert eine Schwarm-Definition.

> **Tipp · Core und Dev Studio können nebeneinander laufen** Dev Studio hat Personas, die sich mit Atlas, Forge, Sentinel und Nexus überschneiden. Installiere gern beide: Wähle die Persona, deren Workflow du willst. Das Design-Pack geht weiter: Ist es installiert, bestimmen seine Regeln visuelles Design und Barrierefreiheit, und Sentinels UX-Review gibt diese Themen ab.

**Siehe auch**

- [Alle zehn Packs im Vergleich](https://bmad-plus.rochetta.fr/de/docs/packs/packs-overview/)
- [Wie Agenten aktiviert werden](https://bmad-plus.rochetta.fr/de/docs/agents/agents-activation/)
- [Dev-Studio-Pack](https://bmad-plus.rochetta.fr/de/docs/packs/dev-studio/)
- [Referenz des Befehls install](https://bmad-plus.rochetta.fr/de/docs/reference/cli-install/)
- [Konfigurationsdatei](https://bmad-plus.rochetta.fr/de/docs/reference/config-yaml/)
- [Abnahmeprotokolle (uat)](https://bmad-plus.rochetta.fr/de/docs/reference/cli-uat/)

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

[Quellcode auf GitHub](https://github.com/lrochetta/BMAD-PLUS)