# Kiro CLI verwenden: Schritt-für-Schritt-Anleitung

URL: https://agentvera.dev/de/blog/how-to-use-kiro-cli/ · Veröffentlicht: 2026-10-29

Kiro CLI verwenden: kiro-cli installieren, anmelden, mit dem Code chatten, Modell wählen und Steering-Dateien, eigene Agenten, MCP-Server und Specs einrichten.

**Kurz gesagt:**

- Mit dem offiziellen Skript, Homebrew oder PowerShell installieren, im Browser mit GitHub, Google, AWS Builder ID oder IAM Identity Center anmelden, dann kiro-cli im Projekt starten und die Änderung beschreiben.
- Projektregeln gehören nach .kiro/steering/ oder in AGENTS.md, eigene Agenten nach .kiro/agents/, MCP-Server in .kiro/settings/mcp.json; /spec zerlegt ein Feature in Anforderungen, Design und Aufgaben.
- Stand Oktober 2026 rechnet Kiro in Credits ab: 50 im Free-Tarif, 1.000 bei Pro für 20 $ im Monat. Auto wählt das Modell für dich; jedes Modell hat seinen eigenen Credit-Multiplikator.

Um Kiro CLI zu verwenden, installierst du es mit `curl -fsSL https://cli.kiro.dev/install | bash` (auf macOS auch mit `brew install kiro-cli`), meldest dich im Browser an, startest `kiro-cli` in einem Projektordner und beschreibst, was du willst. Kiro liest deinen Code, bearbeitet Dateien und führt Befehle aus. Bevor es ein Tool nutzt, dem du noch nicht vertraust, fragt es nach. Mit `/model` wählst du ein Modell, oder du lässt Auto eingestellt und Kiro entscheiden.

Das ist der Grundablauf. Diese Anleitung behandelt den Rest: Anmeldung, die Chat-Befehle für jeden Tag, Modelle und Credits, Steering-Dateien, eigene Agenten, MCP-Server, Specs, Kiro in der CI und Kiro neben anderen Agenten. Alles hier folgt der offiziellen Kiro-Dokumentation mit Stand Oktober 2026.

## Was Kiro ist

Kiro ist die agentische Entwicklungsumgebung von AWS. Es gibt sie in mehreren Formen, die sich ein Konto teilen: eine Desktop-IDE, die CLI und Kiro Web. Die CLI ist die Terminal-Seite. Sie bietet einen interaktiven Chat mit Vollbild-Terminal-Oberfläche, einen Headless-Modus für Skripte und CI, und sie kann als Agent für Editoren dienen, die das Agent Client Protocol (ACP) sprechen.

Was Kiro von anderen Coding-Agenten unterscheidet, ist der Fokus auf Specs. Bevor Kiro Code für ein Feature schreibt, kann es deine Idee in Anforderungen, ein Design und eine Aufgabenliste verwandeln und die Aufgaben dann abarbeiten. Ist dir der Ansatz neu, erklärt [Spec-Driven Development mit KI-Agenten](/de/blog/spec-driven-development-with-ai/ "Spec-Driven Development mit KI-Agenten") die Idee und vergleicht Kiro mit anderen Tools, die das können.

Ein Hinweis zu den Versionen: Der Installer liefert Kiro CLI 2.x. Version 3 ist eine frühe Version, die du mit `kiro-cli --v3` ausprobieren kannst. Sie läuft neben deiner 2.x-Installation, und dein Setup bleibt, wie es ist, bis du wechselst. Diese Anleitung folgt 2.x und weist darauf hin, wo V3 abweicht.

## Schritt 1: Kiro CLI installieren

| Plattform | Befehl |
| --- | --- |
| macOS, Linux | `curl -fsSL https://cli.kiro.dev/install \| bash` |
| macOS (Homebrew) | `brew install kiro-cli` |
| Windows 11 (PowerShell) | `irm 'https://cli.kiro.dev/install.ps1' \| iex` |

Unter Linux gibt es außerdem ein `.deb`-Paket, ein AppImage und eine Zip-Datei. Die CLI braucht glibc 2.34 oder neuer; auf älteren Distributionen nimmst du die musl-Variante der Zip-Datei. Unter Windows führst du den Installer in PowerShell oder im Windows Terminal aus; die alte Eingabeaufforderung wird nicht unterstützt.

Prüfe, ob alles läuft:

```bash
kiro-cli doctor
```

`kiro-cli update` sucht nach einer neuen Version, und `kiro-cli settings app.disableAutoupdates true` schaltet die automatischen Updates ab. Mit Homebrew aktualisierst du über `brew upgrade --greedy kiro-cli`.

## Schritt 2: anmelden

Nach der Installation öffnet Kiro den Browser zur Anmeldung. Zur Wahl stehen:

- **GitHub oder Google:** der schnellste Weg für Einzelpersonen.
- **AWS Builder ID:** eine kostenlose persönliche AWS-Identität.
- **AWS IAM Identity Center:** für Unternehmen, die Kiro über AWS verwalten. Du gibst die Start-URL und die Region deiner Organisation ein.
- **Ein externer Identitätsanbieter:** etwa Okta oder Microsoft Entra ID, wenn dein Unternehmen das eingerichtet hat.

Mit `kiro-cli login` meldest du dich jederzeit neu an. Auf einem entfernten Rechner ohne Browser gibt `kiro-cli login --use-device-flow` eine URL und einen Code aus, die du auf einem anderen Gerät öffnest. Der Device Flow funktioniert mit Builder ID, IAM Identity Center, Google und GitHub, aber nicht mit einem externen Identitätsanbieter. `kiro-cli whoami` zeigt, mit welchem Konto du angemeldet bist, `kiro-cli logout` meldet dich ab.

Gut zu wissen: Im Free-Tarif und in den Einzeltarifen darf Kiro deine Inhalte zur Verbesserung des Dienstes nutzen. Du kannst widersprechen; wie das geht, steht in der Kiro-Dokumentation.

## Schritt 3: Chat-Grundlagen

Wechsle in ein Projekt und starte Kiro:

```bash
cd my-project
kiro-cli
```

Standard ist die Terminal-Oberfläche. Ein paar Dinge brauchst du ständig:

- **`@pfad`** hängt eine Datei an deine Nachricht.
- **`!`** am Zeilenanfang führt einen Shell-Befehl direkt aus, zum Beispiel `!npm test`.
- **Shift+Tab** wechselt in den Plan-Modus, in dem Kiro eine Änderung durchdenkt, bevor es Code anfasst.
- **Shift+Enter** oder **Ctrl+J** beginnt eine neue Zeile, **Ctrl+O** klappt lange Ausgaben auf, **Ctrl+C** beendet.
- **`/paste`** fügt ein Bild aus der Zwischenablage ein.

| Befehl | Was er tut |
| --- | --- |
| `/model` | Modell wählen |
| `/effort` | Reasoning-Effort einstellen |
| `/agent` | Zu einem anderen Agenten wechseln |
| `/context` | Kontextdateien anzeigen, hinzufügen oder entfernen |
| `/compact` | Den Chat zusammenfassen, um Kontext freizumachen |
| `/plan` | Eine Änderung planen, bevor sie umgesetzt wird |
| `/spec` | Eine Spec anlegen oder ausführen |
| `/tools` | Tools vertrauen oder das Vertrauen entziehen |
| `/mcp` | MCP-Server prüfen und sich bei ihnen anmelden |
| `/usage` | Tarif und verbleibende Credits anzeigen |
| `/guide` | Fragen zu Kiro CLI selbst stellen |
| `/quit` | Beenden |

Chats werden pro Ordner gespeichert. `kiro-cli chat --resume` setzt den letzten Chat im aktuellen Ordner fort, mit `--resume-picker` wählst du einen aus, `--list-sessions` listet sie auf. Wer die ältere zeilenweise Oberfläche mag, startet mit `kiro-cli chat --classic`.

## Schritt 4: Modelle und Credits

Standardmäßig nutzt Kiro **Auto**, das jede Anfrage an ein passendes Modell weiterleitet. Die Dokumentation empfiehlt es für die meisten Aufgaben. Willst du selbst wählen, tippe im Chat `/model` oder liste die Modelle in der Shell auf:

```bash
kiro-cli chat --list-models
```

Ein Modell machst du in den Einstellungen zum Standard:

```bash
kiro-cli settings chat.defaultModel "claude-sonnet-4.6"
```

Kiro rechnet in Credits ab, und jedes Modell hat einen Multiplikator. Stand Oktober 2026 kostet Claude Opus 5 das 2,2-Fache, Claude Sonnet 5.5 das 1,3-Fache, DeepSeek 3.2 das 0,25-Fache und Qwen3 Coder Next das 0,05-Fache. Dieselbe Aufgabe kostet je nach Modell sehr unterschiedlich viel, also wirf ab und zu einen Blick auf `/usage`.

| Tarif (Oktober 2026) | Preis | Credits |
| --- | --- | --- |
| Free | 0 $ | 50 |
| Pro | 20 $ pro Nutzer und Monat | 1.000 |
| Pro+ | 40 $ pro Nutzer und Monat | 2.000 |
| Pro Max | 100 $ pro Nutzer und Monat | 5.000 |
| Power | 200 $ pro Nutzer und Monat | 10.000 |
| Enterprise | Auf Anfrage | Individuell |

Bezahlte Tarife können über ihre Credits hinaus für 0,04 $ pro Credit weiterlaufen, und es gibt Zusatzpakete. Der Free-Tarif umfasst Open-Weight-Modelle und Claude Sonnet 4.5; für die neuesten Claude-Modelle brauchst du einen bezahlten Tarif. Preise und Modelle ändern sich oft, schau vor der Entscheidung auf kiro.dev/pricing.

## Schritt 5: Steering-Dateien und AGENTS.md

Steering-Dateien sind Markdown-Dateien mit deinen Projektregeln: was das Produkt tut, der Tech-Stack, wo was liegt, was zu vermeiden ist. Kiro sucht sie an zwei Orten:

- **Workspace:** `.kiro/steering/` im Projekt, zusammen mit dem Code eingecheckt.
- **Global:** `~/.kiro/steering/`, für Regeln, die überall gelten sollen. Widersprechen sich beide, gewinnt der Workspace.

Die Dokumentation empfiehlt drei Dateien als Start: `product.md`, `tech.md` und `structure.md`. Eine Steering-Datei wird standardmäßig in jeden Chat einbezogen. Per Front Matter lässt sie sich auf bestimmte Dateien beschränken:

```markdown
---
inclusion: fileMatch
fileMatchPattern: "components/**/*.tsx"
---

- Komponenten sind Funktionskomponenten mit benannten Exporten.
- Styles nutzen CSS-Module; keine Inline-Styles.
```

Es gibt vier Modi: `always` (Standard), `fileMatch`, `manual` (du holst die Datei mit `#dateiname` dazu) und `auto` (Kiro entscheidet anhand von Name und Beschreibung der Datei). Kiro CLI 2.x lädt nur `always`-Dateien automatisch; V3 unterstützt alle vier.

Kiro liest außerdem `AGENTS.md` und behandelt sie als Steering-Datei, die immer einbezogen wird. Pflegt dein Team schon eine für Codex, opencode oder andere Agenten, nutzt Kiro sie unverändert. Was hineingehört, steht in [CLAUDE.md Best Practices](/de/blog/claude-md-agents-md/ "CLAUDE.md Best Practices").

## Schritt 6: eigene Agenten

Ein eigener Agent ist ein gespeichertes Setup mit eigenem Prompt, Modell, Tools und Kontextdateien. Du legst ihn so an:

```bash
kiro-cli agent create my-agent
```

Agenten liegen in `.kiro/agents/` (pro Projekt) oder `~/.kiro/agents/` (global), als JSON oder in V3 auch als Markdown. Ein kurzes Beispiel:

```json
{
  "name": "my-agent",
  "description": "Reviews backend changes",
  "prompt": "You are a careful backend reviewer.",
  "model": "claude-sonnet-4.6",
  "includeMcpJson": true,
  "resources": ["file://.kiro/steering/**/*.md", "file://./ARCHITECTURE.md"]
}
```

Einen Chat mit ihm startest du per `kiro-cli --agent my-agent`, im Chat wechselst du mit `/agent`, und mit `kiro-cli settings chat.defaultAgent my-agent` wird er zum Standard. `kiro-cli agent list` zeigt deine Agenten, `kiro-cli agent validate` prüft eine Datei.

Zwei Stolperfallen. Erstens beziehen eigene Agenten Steering-Dateien nicht von selbst ein; deshalb steht `.kiro/steering/**/*.md` im Beispiel unter `resources`. Zweitens werden Agenten aus einem Projektordner erst geladen, wenn du diesem Workspace vertraust. Die Felder für Tool-Berechtigungen unterscheiden sich zwischen 2.x und V3; `/upgrade-agent` konvertiert einen Agenten beim Wechsel auf V3.

## Schritt 7: MCP-Server

[MCP-Server](/de/blog/what-is-mcp-server/ "Was ist ein MCP-Server") geben Kiro neue Tools: Doku-Suche, einen Browser, deinen Issue-Tracker. Sie gehören in eine `mcp.json`, entweder `.kiro/settings/mcp.json` im Projekt oder `~/.kiro/settings/mcp.json` für alle Projekte:

```json
{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"],
      "disabled": false
    },
    "my-remote": {
      "url": "https://mcp.example.com/mcp"
    }
  }
}
```

Ein lokaler Server ist ein Befehl, den Kiro startet; ein entfernter Server ist eine URL (HTTPS oder HTTP auf localhost), optional mit `headers` und OAuth-Anmeldung. `kiro-cli mcp add` fügt in der Shell einen Server hinzu, `kiro-cli mcp list` zeigt die Konfiguration und `kiro-cli mcp status`, ob jeder Server läuft. Im Chat erledigt `/mcp` dasselbe und kümmert sich um Server, die eine Anmeldung verlangen.

Ist derselbe Server an mehreren Stellen definiert, schlägt die Einstellung eines Agenten die Workspace-Datei und die Workspace-Datei die globale. Jeder Server bringt Tools in den Kontext, also schalte nicht benötigte mit `"disabled": true` ab.

## Schritt 8: Specs

Specs sind Kiros Markenzeichen. Für alles, was größer ist als ein schneller Fix, legst du eine an:

```text
/spec new user-invitations
```

Kiro schreibt drei Dateien nach `.kiro/specs/user-invitations/`: `requirements.md` mit User Stories und Akzeptanzkriterien in EARS-Notation („Wenn X, soll das System Y“), `design.md` mit dem technischen Ansatz und `tasks.md` mit einer nummerierten Aufgabenliste. Lies und korrigiere jede Datei, bevor es weitergeht; genau diese Prüfung ist der Sinn der Sache. Dann lässt du Kiro die Aufgaben abarbeiten:

```text
/spec run user-invitations
```

Die Spec-Dateien sind schlichtes Markdown. Checkst du sie ein, werden sie zur Dokumentation für die nächste Änderung. Bei kleineren Änderungen bietet der Plan-Modus (Shift+Tab oder `/plan`) eine leichtere Variante derselben Gewohnheit.

## Schritt 9: Headless-Modus und CI

Für Skripte und CI läuft Kiro ohne Chat-Oberfläche:

```bash
export KIRO_API_KEY=your-key
kiro-cli chat --v3 --no-interactive --trust-tools=read_file,grep_search "Summarize the risky changes in this branch"
```

`--trust-tools` listet die Tools, die Kiro ohne Nachfrage nutzen darf (die Namen hier stammen aus V3, deshalb nutzt das Beispiel `--v3`, wie auch das GitHub-Actions-Beispiel der Dokumentation). `--trust-all-tools` erlaubt alles, also nur in einer Sandbox verwenden. `--require-mcp-startup` lässt den Lauf scheitern, wenn ein MCP-Server nicht startet. API-Schlüssel gibt es in den Tarifen Pro, Pro+, Pro Max und Power. Für Editoren mit ACP-Unterstützung startet `kiro-cli acp` Kiro als deren Agenten.

## Häufige Stolperfallen

- **Der Installer scheitert unter Windows.** Du bist in der Eingabeaufforderung. Nutze PowerShell oder das Windows Terminal unter Windows 11.
- **Das Programm startet auf einem älteren Linux nicht.** glibc ist älter als 2.34. Nimm die musl-Zip-Datei.
- **Deine Steering-Regeln werden ignoriert.** Die Datei nutzt `fileMatch` oder `auto`, was 2.x nicht automatisch lädt, oder du bist in einem eigenen Agenten ohne die Steering-Ressource.
- **Credits schmelzen schnell.** Ein teures Modell oder ein langer Chat. Prüfe `/usage`, probier Auto und nutze `/compact`.
- **AWS-Befehle funktionieren in V3 nicht mehr.** V3 hat das eingebaute AWS-Tool entfernt; nutze stattdessen einen AWS-MCP-Server.
- **Keine Option für einen API-Schlüssel.** Der Headless-Modus braucht einen bezahlten Tarif.

## Kiro CLI oder ein anderer Agent?

Kiro passt gut, wenn du gern mit Specs planst, wenn dein Unternehmen den Zugriff schon über AWS IAM Identity Center verwaltet oder wenn du Premium-Modelle und günstige Open-Weight-Modelle über eine Rechnung abdecken willst. Weniger passt es, wenn du deinen eigenen API-Schlüssel mitbringen oder lokale Modelle nutzen willst; das kann [opencode](/de/blog/how-to-use-opencode/ "opencode verwenden") mit jedem Anbieter. Zahlst du schon für Claude oder ChatGPT, nutzen Claude Code oder Codex CLI dieses Abo direkt. [Die besten Claude-Code-Alternativen](/de/blog/best-claude-code-alternatives/ "Die besten Claude-Code-Alternativen") vergleicht die wichtigsten CLI-Agenten nebeneinander.

## Kiro CLI neben anderen Agenten ausführen

Viele Teams entscheiden sich nicht für nur einen Agenten. Kiro schreibt die Spec, Claude Code oder Codex baut einen Teil, ein weiterer Agent prüft. Mit Terminal-Tabs wird das schnell unübersichtlich. AgentVera ist eine Desktop-App, die diese CLIs nebeneinander in echten Terminals ausführt, mit deinen eigenen Installationen und Logins. Die [Kiro-CLI-Unterstützung](/de/agents/kiro-cli/ "Kiro CLI in AgentVera") funktioniert so:

- **Dein Kiro-Login.** AgentVera öffnet `kiro-cli chat` in einem echten Terminal. Du meldest dich mit `kiro-cli login` an; bist du abgemeldet, fordert dich das Terminal des Agenten zur Anmeldung auf.
- **Modell und Effort pro Agent.** Lass das Modell leer für Kiros Standard oder wähle pro Agent eines. Der Effort reicht von niedrig bis max.
- **Regeln aus deinen Dateien.** Kiro CLI hat kein Flag für zusätzliche Anweisungen, dauerhafte Anweisungen kommen also aus `AGENTS.md` oder Regeldateien im Projekt.
- **Deine mcp.json bleibt deine.** Die MCP-Server, die du in AgentVera hinzufügst, und der Browser von AgentVera werden bei jedem Start mit deiner eigenen Kiro-`mcp.json` zusammengeführt.
- **Sessions laufen weiter.** Setzt du einen Agenten fort, öffnet er sich mit seiner Session-ID oder der letzten Session des Ordners.
- **Panes, Flows und Review.** Lass Kiro im Raster des [Workspace](/de/features/workspace/ "Workspace") neben Claude Code oder Codex laufen, jeden in seinem eigenen Git-Worktree. Kiro-Agenten funktionieren in Flows, Broadcasts und geplanten Aufgaben und bekommen ein automatisches Code-Review, wenn ein Turn endet.

Raster, Worktrees, Code-Review und MCP-Manager gehören zum Free-Tarif; Flows gibt es in Pro und Team. [Lade AgentVera herunter](/de/download/ "AgentVera herunterladen") und probiere es aus.

## Fazit

Um Kiro CLI zu verwenden, installierst du es, meldest dich an, startest `kiro-cli` in einem Projekt und beschreibst die Änderung. Lass das Modell auf Auto, bis du einen Grund hast, es zu ändern, und behalte `/usage` im Blick. Projektregeln kommen nach `.kiro/steering/` oder in `AGENTS.md`, Tools in die `mcp.json`, wiederkehrende Setups in eigene Agenten. Für alles, was größer ist als ein schneller Fix, beginnst du mit `/spec new`: Anforderungen und eine Aufgabenliste zu prüfen, bevor Code entsteht, kann Kiro am besten.

## Häufige Fragen

**Ist Kiro CLI kostenlos?** Die CLI kostet nichts, und der Free-Tarif enthält 50 Credits. Stand Oktober 2026 beginnen die bezahlten Tarife bei 20 $ im Monat für 1.000 Credits (Pro), darüber liegen Pro+, Pro Max und Power. Zusätzliche Nutzung kostet 0,04 $ pro Credit.

**Was ist der Unterschied zwischen Kiro IDE und Kiro CLI?** Es sind zwei Zugänge zu demselben Kiro: Die IDE ist ein Desktop-Editor, die CLI ein Chat im Terminal. Beide nutzen dein Kiro-Konto und deine Credits und verstehen Steering-Dateien, Specs und MCP-Server im Ordner .kiro.

**Liest Kiro CLI die AGENTS.md?** Ja. Kiro behandelt AGENTS.md wie eine Steering-Datei, die immer einbezogen wird. Kiros eigene Steering-Dateien liegen im Projekt unter .kiro/steering/ und für globale Regeln unter ~/.kiro/steering/.

**Was ist Kiro CLI V3?** Eine frühe Version der nächsten Generation. Du probierst sie mit kiro-cli --v3 aus; sie läuft neben deiner 2.x-Installation, die unverändert bleibt, bis du wechselst. Sie teilt sich die Engine mit der Kiro IDE und bringt unter anderem /rewind, Hooks und einen Spec-Agenten.

**Kann ich Kiro CLI in der CI nutzen?** Ja. Starte kiro-cli chat --no-interactive mit einem Prompt und setze KIRO_API_KEY. API-Schlüssel gibt es in den Tarifen Pro, Pro+, Pro Max und Power, nicht im Free-Tarif.

---

**Über AgentVera.** AgentVera ist eine Desktop-App für macOS, Windows und Linux, entwickelt von Solviera Teknoloji. Sie führt 18 KI-Coding-Agenten (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) nebeneinander aus, pro Projekt, in echten Terminals mit den eigenen CLI-Installationen und Logins des Nutzers. Der kostenlose Plan hat unbegrenzt viele Agenten. Download: https://agentvera.dev/de/download/ · Preise: https://agentvera.dev/de/pricing/