# Goose nutzen: Schritt-für-Schritt-Anleitung zur Goose CLI

URL: https://agentvera.dev/de/blog/how-to-use-goose/ · Veröffentlicht: 2026-11-10

So nutzt du den Open-Source-Agent Goose: CLI installieren, goose configure ausführen, Modus wählen, MCP-Extensions hinzufügen, AGENTS.md schreiben und Recipes nutzen.

**Kurz gesagt:**

- Installiere die Goose CLI mit einem curl-Befehl (oder brew install block-goose-cli), lass goose configure Anbieter und Modell wählen, starte dann goose session im Projekt und beschreibe die Aufgabe.
- Goose startet im Modus auto und führt Tools ohne Rückfrage aus. Wechsle mit /mode oder über GOOSE_MODE zu approve oder smart_approve, bevor du es auf ein echtes Repository loslässt.
- Projektregeln gehören in AGENTS.md oder .goosehints, MCP-Server sind Extensions in ~/.config/goose/config.yaml, und goose run --recipe wiederholt eine Aufgabe aus einer YAML-Datei.

Um Goose zu nutzen, installierst du die CLI mit `curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash`, beantwortest die Fragen von `goose configure`, um Anbieter und Modell zu wählen, startest dann `goose session` in einem Projekt und beschreibst, was du willst. **Goose startet im Modus auto und führt Befehle deshalb ohne Rückfrage aus, bis du in den Modus approve wechselst.**

Diese Anleitung behandelt jeden Schritt für die Goose CLI, Stand November 2026 (Version 1.58): Installation, Einrichtung, Modi, Sitzungen, Extensions, Anweisungsdateien und Recipes, dazu die Fehler, die am meisten Zeit kosten.

## Was ist Goose?

Goose ist ein universeller KI-Agent, der auf deinem Rechner läuft. Es gibt ihn als CLI, als Desktop-App für macOS, Linux und Windows und als API, alles in Rust gebaut. Goose ist an kein Modell gebunden: Du bringst einen Anbieter mit, etwa Anthropic, OpenAI, Gemini, OpenRouter oder ein lokales Modell, und Goose übernimmt Tool-Aufrufe, Bearbeitungen und die Arbeit in der Shell.

Block hat Goose entwickelt und es im Dezember 2025 zusammen mit MCP und AGENTS.md an die [Agentic AI Foundation](https://www.linuxfoundation.org/press/linux-foundation-announces-the-formation-of-the-agentic-ai-foundation "Agentic AI Foundation") unter dem Dach der Linux Foundation übergeben. Im April 2026 ist das Repository nach [aaif-goose/goose](https://github.com/aaif-goose/goose "Goose auf GitHub") umgezogen und die Dokumentation nach [goose-docs.ai](https://goose-docs.ai "Goose-Dokumentation"). Ältere Links auf `block/goose` und `block.github.io/goose` leiten weiterhin um. Goose steht unter Apache-2.0, und neue Versionen erscheinen etwa einmal pro Woche.

## Schritt 1: CLI installieren

Unter macOS, Linux oder Git Bash unter Windows:

```bash
curl -fsSL https://github.com/aaif-goose/goose/releases/download/stable/download_cli.sh | bash
```

Unter macOS geht stattdessen auch Homebrew. Die Paketnamen enthalten noch „block“:

```bash
brew install block-goose-cli        # CLI
brew install --cask block-goose     # desktop app
```

In der Windows PowerShell:

```powershell
Invoke-WebRequest -Uri "https://raw.githubusercontent.com/aaif-goose/goose/main/download_cli.ps1" -OutFile "download_cli.ps1"; .\download_cli.ps1
```

Die Windows-Binärdatei landet in `%USERPROFILE%\.local\bin`, das du eventuell zum `PATH` hinzufügen musst. Später aktualisierst du mit `goose update`. CLI und Desktop-App teilen sich eine Konfiguration, Anbieter und Extensions aus der einen tauchen also auch in der anderen auf.

## Schritt 2: goose configure ausführen

Beim ersten Start läuft `goose configure` von selbst. Du hast drei Wege: bei OpenRouter anmelden, beim Tetrate Agent Router Service anmelden oder manuell konfigurieren, indem du einen Anbieter wählst, seinen Key einfügst und ein Modell angibst. Seit Version 1.54 fragt es außerdem, in welchem Modus du starten willst.

Keys landen im Schlüsselbund deines Systems (unter macOS in der Keychain). Gibt es keinen Schlüsselbund oder setzt du `GOOSE_DISABLE_KEYRING`, landen sie stattdessen in einer Klartextdatei `secrets.yaml`. Du kannst sie auch exportieren:

```bash
export ANTHROPIC_API_KEY=...
export GOOSE_PROVIDER=anthropic
export GOOSE_MODEL=claude-sonnet-5-5
```

Ein Key, der in `config.yaml` steht, wird ignoriert. Führe `goose configure` jederzeit erneut aus, um den Anbieter zu wechseln, Extensions hinzuzufügen oder an- und abzuschalten oder die Einstellungen für Modus und Tool-Berechtigungen zu öffnen.

Bezahlst du schon für Claude Code oder ChatGPT Plus/Pro, sieh dir die [ACP-Provider](https://goose-docs.ai/docs/guides/acp-providers "Goose ACP-Provider") an: Mit ihnen nutzt Goose diese Anmeldung statt eines API-Keys.

## Schritt 3: Sitzung starten

```bash
cd my-project
goose session -n checkout-fix
```

Beschreibe die Aufgabe in einfachen Worten. Nützliche Tasten und Befehle in einer Sitzung:

- `Ctrl+J` fügt eine neue Zeile ein; `Ctrl+C` stoppt die laufende Anfrage oder beendet Goose in einer leeren Zeile.
- `/mode`, `/model`, `/extension` und `/builtin` ändern die Einrichtung, ohne die Sitzung zu verlassen.
- `/compact` kürzt die Unterhaltung, wenn sie lang wird; `/clear` fängt von vorn an.
- `/status` zeigt die Sitzung samt ihrer ID.

Um später weiterzumachen, führst du `goose session -r -n checkout-fix` aus. `goose session list` zeigt alle Sitzungen, und `--fork` kopiert eine, sodass du eine andere Richtung ausprobieren kannst, ohne das Original zu verlieren.

## Schritt 4: Modus vor der echten Arbeit wählen

Goose hat vier Modi:

| Modus | Was er tut |
|---|---|
| `auto` (Standard) | Führt jedes Tool ohne Rückfrage aus |
| `approve` | Fragt vor jedem Tool-Aufruf |
| `smart_approve` | Fragt nur bei Aufrufen, die es als riskant einstuft |
| `chat` | Keine Tools; nur Unterhaltung |

Du wechselst mit `/mode approve` in einer Sitzung, setzt `GOOSE_MODE` oder wählst einen Standard in `goose configure`. Für feinere Kontrolle legst du in `goose configure` Berechtigungen pro Tool fest; sie werden in `permission.yaml` gespeichert. In einem Repository, das dir wichtig ist, startest du mit `approve` oder `smart_approve` und lockerst das, sobald du der Einrichtung vertraust.

## Schritt 5: Extensions und MCP-Server

Über Extensions bekommt Goose seine Tools, und jeder MCP-Server ist eine Extension. Die Developer-Extension (Shell und Dateibearbeitung) ist standardmäßig an. Weitere eingebaute sind Computer Controller, Memory und Auto Visualiser.

Um eine dauerhaft hinzuzufügen, führst du `goose configure` → **Add Extension** aus und wählst einen Kommandozeilen-Server (stdio) oder einen entfernten Server (Streamable HTTP). Für eine einzelne Sitzung:

```bash
goose session --with-extension "memory:npx -y @modelcontextprotocol/server-memory"
goose session --with-streamable-http-extension https://example.com/mcp
```

Gespeicherte Extensions stehen unter `extensions:` in `~/.config/goose/config.yaml` (Windows: `%APPDATA%\Block\goose\config\config.yaml`). SSE-Server werden nicht mehr unterstützt; nimm Streamable HTTP.

## Schritt 6: AGENTS.md und .goosehints

Goose liest `AGENTS.md` und danach `.goosehints` auf jeder Ebene vom Arbeitsordner bis zur Git-Wurzel und bezieht verschachtelte Dateien ein, sobald es in Unterordnern arbeitet. Eine globale Datei unter `~/.config/goose/.goosehints` gilt für jedes Projekt.

Hat dein Projekt schon eine `CLAUDE.md`, musst du sie nicht kopieren:

```bash
export CONTEXT_FILE_NAMES='["AGENTS.md", ".goosehints", "CLAUDE.md"]'
```

Halte die Datei kurz: der Stack, wie Tests laufen, was tabu ist und was „fertig“ bedeutet. Was hineingehört, erklärt der Beitrag [CLAUDE.md und AGENTS.md schreiben](/de/blog/claude-md-agents-md/ "CLAUDE.md und AGENTS.md schreiben").

## Schritt 7: goose run und Recipes

Für einmalige Aufgaben ohne Chat nimmst du `goose run`:

```bash
goose run -t "add a unit test for the price formatter"
goose run -i task.md --output-format json
```

Ein Recipe ist eine YAML-Datei, die eine Aufgabe mit ihren Anweisungen, Extensions und Parametern speichert, sodass ein Teammitglied oder ein geplanter Job sie wiederholen kann:

```bash
goose run --recipe release-notes.yaml --params version=2.4.0
goose schedule add --schedule-id weekly-notes --cron "0 0 9 * * 1" --recipe-source release-notes.yaml
```

`goose recipe validate` prüft eine Datei, bevor du sie teilst. Zwei weitere Befehle lohnen sich: `goose review` fordert ein KI-Review deines Git-Diffs an, und `goose info -v` zeigt die Version und wo Konfiguration, Sitzungen und Logs liegen.

## Typische Stolperfallen

- **Den Modus auto anlassen.** Der Standard führt Shell-Befehle ohne Rückfrage aus. Wechsle den Modus vor der ersten Aufgabe in einem echten Repository.
- **Alter Doku folgen.** Tutorials aus 2025 verweisen auf `block/goose` und `block.github.io`. Die Befehle funktionieren meist noch, aber die aktuelle Doku liegt auf goose-docs.ai.
- **Keys in config.yaml eintragen.** Goose ignoriert sie dort. Nutze den Schlüsselbund, `goose configure` oder Umgebungsvariablen.
- **Die veralteten CLI-Provider nutzen.** Um mit einer Claude-Code- oder ChatGPT-Anmeldung zu arbeiten, richte stattdessen einen ACP-Provider ein.
- **Lange Sitzungen.** Die automatische Kompaktierung hält den Kontext im Rahmen, aber eine frische, benannte Sitzung pro Aufgabe hält die Antworten präziser.

## Goose neben anderen CLIs in AgentVera betreiben

Goose hat eine eigene Desktop-App, und wenn Goose dein einziger Agent ist, reicht sie vielleicht schon. Schwieriger wird es, wenn Goose im selben Projekt neben Claude Code, Codex oder Gemini CLI läuft. [AgentVera](/de/ "AgentVera") ist eine Desktop-App, die diese CLIs nebeneinander in echten Terminals ausführt, mit deinen eigenen Installationen und Keys. Die [Goose-Unterstützung](/de/agents/goose/ "Goose in AgentVera") funktioniert so:

- **Eine benannte Sitzung pro Agent.** Jeder Goose-Agent bekommt einen eigenen Sitzungsnamen, und AgentVera öffnet sie bei späteren Starts mit `goose session --resume --name` wieder, sodass die Unterhaltung einen Neustart der App übersteht.
- **Dein Anbieter und deine Keys.** Goose nutzt weiter den Anbieter aus `goose configure`. Unter Einstellungen → Konten kannst du Konten mit API-Keys (Anthropic, OpenAI, OpenRouter, Google) für Goose-Agents hinzufügen.
- **Modell, Aufwand und Rolle.** Das gewählte Modell wird mit `--model` übergeben, die Aufwandsstufe über `GOOSE_THINKING_EFFORT` und die Rolle des Agents mit `--system`.
- **MCP und der Browser.** Die Server aus AgentVeras [MCP-Manager](/de/features/mcp-manager/ "MCP-Manager") werden als `--with-extension` oder `--with-streamable-http-extension` übergeben, du richtest sie also einmal für jede CLI ein.
- **Panes, Worktrees und Review.** Lass Goose im [Workspace](/de/features/workspace/ "Workspace")-Raster neben anderen Agents laufen, jeden in seinem eigenen Git-Worktree, und prüfe ihre Änderungen mit dem Code-Review.

Der kostenlose Plan umfasst bis zu 18 Agenten, MCP, Git, Docker, SSH, Code-Review und Token-Einsparungen. Pro kostet 9,99 $ im Monat; wenn du noch nie eine Testphase hattest, schaltet deine erste Anmeldung in der App Pro für 7 Tage frei, ohne Karte. Zum Ausprobieren: [AgentVera herunterladen](/de/download/ "AgentVera herunterladen").

## Fazit

Für den Start mit Goose brauchst du drei Befehle: Installation, `goose configure`, `goose session`. Die wichtigsten Einstellungen kommen direkt danach: vom Modus auto auf approve wechseln, die nötigen Extensions hinzufügen und dem Projekt eine `AGENTS.md` geben. Wiederholt sich eine Aufgabe, speicherst du sie als Recipe.

Quellen: [Goose-Installation](https://goose-docs.ai/docs/getting-started/installation "Goose installieren"), [CLI-Befehle](https://goose-docs.ai/docs/guides/goose-cli-commands "Goose CLI-Befehle"), [Berechtigungen](https://goose-docs.ai/docs/guides/managing-tools/goose-permissions "Goose-Berechtigungsmodi"), [Extensions](https://goose-docs.ai/docs/getting-started/using-extensions "Extensions nutzen"), [Hints-Dateien](https://goose-docs.ai/docs/guides/context-engineering/using-goosehints "Mit .goosehints arbeiten"), [Releases](https://github.com/aaif-goose/goose/releases "Goose-Releases").

## Häufige Fragen

**Ist Goose kostenlos?** Ja. Goose ist Open Source unter der Apache-2.0-Lizenz und kostet nichts. Du bezahlst deinen Modellanbieter für die verbrauchten Tokens oder lässt ein lokales Modell über Ollama, LM Studio oder Docker Model Runner ohne Token-Kosten laufen.

**Wer entwickelt Goose heute?** Block hat Goose entwickelt und es im Dezember 2025 an die Agentic AI Foundation (AAIF) unter dem Dach der Linux Foundation übergeben. Seit April 2026 liegt der Code auf github.com/aaif-goose/goose und die Dokumentation auf goose-docs.ai.

**Kann Goose mein Claude-Code- oder ChatGPT-Abo nutzen?** Ja, über ACP-Provider, mit denen Goose eine bestehende Anmeldung bei Claude Code oder ChatGPT Plus/Pro nutzt. Die älteren CLI-Provider, die das bisher erledigten, sind zugunsten der ACP-Provider veraltet.

**Liest Goose AGENTS.md oder CLAUDE.md?** Goose liest AGENTS.md und danach .goosehints auf jeder Ebene vom Arbeitsordner bis zur Git-Wurzel. Um auch CLAUDE.md oder .cursorrules zu laden, trägst du sie in die Umgebungsvariable CONTEXT_FILE_NAMES ein.

**Fragt Goose nach, bevor es Befehle ausführt?** Standardmäßig nicht. Der Standardmodus ist auto, der Tools ohne Rückfrage ausführt. Der Modus approve fragt vor jedem Tool-Aufruf, smart_approve nur bei riskanten, und der Modus chat schaltet Tools ganz ab.

---

**Ü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/