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

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

So nutzt du den Coding-Agent Amp: CLI installieren, anmelden, einen Modus auf dem Dial wählen und AGENTS.md, MCP-Server, Subagents und Credits einrichten.

**Kurz gesagt:**

- Installiere die Amp CLI mit einem curl-Befehl (macOS, Linux, Windows über WSL), führe amp login aus und starte dann amp im Projekt. Jede Unterhaltung ist ein Thread, der auf ampcode.com gespeichert wird.
- Statt eines Modells wählst du auf dem Dial einen Modus: low, medium, high oder ultra. Wähle ihn vor der ersten Nachricht mit Strg+S, denn ein Thread behält seinen Modus.
- Projektregeln gehören in AGENTS.md, Einstellungen und MCP-Server in ~/.config/amp/settings.json oder .amp/settings.json. Hobby ist kostenlos; Modellnutzung läuft über Abos, eigene Keys oder Credits.

Um Amp zu nutzen, installierst du die CLI mit `curl -fsSL https://ampcode.com/install.sh | bash`, meldest dich mit `amp login` an, startest `amp` in einem Projekt und beschreibst, was du willst. Vor der ersten Nachricht wählst du mit Strg+S einen Modus auf dem Dial: `low`, `medium`, `high` oder `ultra`. Danach liest Amp deinen Code, bearbeitet Dateien und führt Befehle aus; die ganze Unterhaltung wird als Thread gespeichert, den du später wieder öffnen oder teilen kannst.

Das ist der Kern. Diese Anleitung deckt den Rest ab: Anmeldung für Skripte und CI, die Tastenkürzel für jeden Tag, Modi, Subagents wie das Oracle, `settings.json`, `AGENTS.md`, MCP-Server, den Execute-Modus, was Amp kostet und wie du es neben anderen CLI-Agents betreibst. Alles hier basiert auf der offiziellen Amp-Dokumentation, Stand Oktober 2026.

## Was ist Amp?

Amp ist ein [Coding-Agent](/de/glossary/coding-agent/ "Was ist ein Coding-Agent") und eine Entwicklungsumgebung. Es ist bei Sourcegraph entstanden und wird seit der Ausgründung im Dezember 2025 von einem eigenständigen Unternehmen entwickelt. Amp ist an keinen Modellanbieter gebunden: Das Modell wählt Amp anhand des Modus, den du einstellst, und es kann dein ChatGPT-Abo, dein Claude-Abo (im Claude-Code-Modus) oder deine eigenen API-Keys nutzen.

Du kannst Amp an drei Stellen verwenden: in der Web-App auf ampcode.com (ohne Installation), in den Apps für macOS, iPhone, iPad und Android und in der Terminal-CLI, um die es hier geht. Jede Unterhaltung ist ein **Thread** mit eigener URL. Amp kann einen Thread auch auf einem **Orb** ausführen, einer Maschine, die Amp für diesen Thread auf seinen Servern anlegt, oder auf einem Runner, den du selbst betreibst.

## Schritt 1: CLI installieren

| Plattform | Befehl |
| --- | --- |
| macOS, Linux | `curl -fsSL https://ampcode.com/install.sh \| bash` |
| Windows | Denselben Befehl in WSL ausführen |

Die CLI unterstützt macOS, Linux und Windows über WSL. Unter Windows empfiehlt die Dokumentation WezTerm oder Alacritty statt Windows Terminal, weil die Zwischenablage dort besser funktioniert. Die Installationsseite hat außerdem Reiter für Windows und Homebrew.

Amp aktualisiert sich im Hintergrund selbst. `amp update` aktualisiert von Hand, `amp version` zeigt die installierte Version, `amp --help` listet alle Befehle. Shell-Vervollständigung ist eine Zeile, etwa `source <(amp completions zsh)` (bash und pwsh gehen auch; fish nutzt `amp completions fish | source`).

## Schritt 2: anmelden

```bash
amp login
```

`amp login` öffnet den Browser und fügt ein Konto hinzu. Die CLI kann mehrere verwalten: `amp account list` zeigt sie an, `amp account switch <email-or-user-id>` wählt das Konto für alle folgenden Befehle, und `amp logout` entfernt das aktive (`--all` entfernt alle).

Für Skripte, CI und Rechner ohne Browser nimmst du stattdessen ein Zugriffstoken:

```bash
export AMP_API_KEY=sgamp_your-token-here
```

Das Token erstellst du in den Einstellungen auf ampcode.com; es beginnt mit `sgamp_`. Das Sitzungstoken, das `amp login` speichert, läuft innerhalb einer Stunde ab und lässt sich nicht erneuern, deshalb lehnt die CLI es an dieser Stelle ab.

Zwei optionale Verknüpfungen ändern, wer die Modellnutzung bezahlt:

- **ChatGPT-Abo:** `amp config model-providers add-chatgpt-subscription` (oder kurz `amp add-chatgpt-sub`) verknüpft einen ChatGPT-Plan, sodass die Nutzung von OpenAI-Modellen darüber läuft.
- **Claude-Abo:** funktioniert nur im **Claude-Code**-Modus von Amp, den du auf dem Dial wählst. Amps eigene Modi laufen nie über deinen Claude-Plan.

## Schritt 3: CLI-Grundlagen

Starte `amp` in einem Projekt und tippe los. Eingaben per Pipe werden zur ersten Nachricht, also funktioniert auch `echo "commit all my changes" | amp`. Das wichtigste Kürzel ist **Strg+O**, es öffnet die Befehlspalette.

| Kürzel | Was es tut |
| --- | --- |
| `Ctrl+O` | Öffnet die Befehlspalette |
| `Ctrl+S` | Dreht den Dial (vor der ersten Nachricht) |
| `@` | Erwähnt eine Datei |
| `Ctrl+V` | Fügt ein Bild ein, auch unter macOS |
| `Ctrl+G` | Schreibt den Prompt in `$EDITOR` |
| `Ctrl+R` | Öffnet den Prompt-Verlauf |
| `Esc Esc` | Unterbricht den Agent |
| `Ctrl+C Ctrl+N` | Archiviert den Thread und startet einen neuen |
| `Ctrl+C Ctrl+C` | Beendet Amp |

Tippst du, während Amp arbeitet, **lenkt** Enter den Agent: Deine Nachricht kommt nach dem aktuellen Schritt an, statt auf das Ende der ganzen Runde zu warten. Um eine Nachricht bis zum Ende einzureihen, führst du in der Palette `prompt: queue message` aus. Shift+Enter fügt in Terminals, die das unterstützen, einen Zeilenumbruch ein; Strg+J funktioniert überall. In tmux brauchst du `tmux set -s extended-keys on`, damit Shift+Enter klappt.

In der Palette verbindet `ide connect` Amp mit VS Code, Cursor, Windsurf, Zed oder Neovim (Neovim braucht ein Plugin). `amp config keymap` listet alle Kürzel.

## Schritt 4: Modus auf dem Dial wählen

Amp fragt dich nicht nach einem Modell, sondern nach einem Modus. Jeder Modus ist eine Kombination aus Modell, Reasoning-Aufwand, System-Prompt und Tools, abgestimmt auf einen Schwierigkeitsgrad:

| Modus | Wofür |
| --- | --- |
| `low` | Kleine, klar umrissene Änderungen |
| `medium` | Die meisten Aufgaben; die Standardempfehlung der Doku |
| `high` | Schwierige oder knifflige Probleme |
| `ultra` | Offene Aufgaben wie Migrationen und Architektur |

Drück **Strg+S vor deiner ersten Nachricht**, um den Dial zu drehen, oder öffne die Palette und tippe `mode`. Ein Thread behält den Modus, mit dem er gestartet ist. Hast du den falschen erwischt, starte lieber einen neuen Thread, statt dagegen anzukämpfen. Zu hoch anzufangen kostet bei einer einfachen Änderung Zeit und Credits; zu niedrig anzufangen kann teurer werden, wenn du mehrere Anläufe brauchst.

Willst du mehr Kontrolle über die Modelle, kannst du unter Einstellungen → Mode Dial → Tune Modes Modelle pro Modus festlegen und eigene API-Keys mitbringen. Wenn du lieber für jede Sitzung ein bestimmtes Modell auswählst, passt ein Multi-Provider-Agent wie opencode besser zu dieser Arbeitsweise.

## Schritt 5: Subagents, Oracle und Librarian

Amp kann abgegrenzte Aufgaben an [Subagents](/de/glossary/subagent/ "Was ist ein Subagent") übergeben, jeder mit eigenem Kontextfenster:

- **Task** erledigt delegierte Arbeit von Anfang bis Ende und meldet sich zurück. Er kann Dateien bearbeiten und Befehle ausführen und hat schreibgeschützte Skills, um deinen Code zu durchsuchen, ein anderes Repository zu recherchieren, eine Änderung zu prüfen und zu planen.
- **Read Thread** liest andere Amp-Threads und fasst sie zusammen.

Beide nutzen dasselbe Modell wie der Thread, der sie gestartet hat. Amp setzt sie bei passenden Aufgaben selbst ein, meist im Modus `medium`, und du kannst sie direkt anfordern: „teile das auf Subagents auf“.

Das Oracle (ein Reviewer, der nie Dateien bearbeitet), der Librarian (klont andere Repositorys nach `/tmp` und erklärt sie) und der Finder (schnelle Codesuche) sind inzwischen Teil von Task. Um sie als eigene Tools mit einem Modell deiner Wahl laufen zu lassen, installierst du sie als Plugins:

```bash
amp plugins add @amp/oracle
amp plugins add @amp/librarian
amp plugins add @amp/finder
```

## Schritt 6: Einstellungen

Amp liest zwei Einstellungsdateien; bei Konflikten gewinnt der Workspace:

- **Benutzer:** `~/.config/amp/settings.json` (oder `.jsonc`).
- **Workspace:** `.amp/settings.json` im Projekt.

`amp config edit` öffnet die Benutzerdatei, `amp config edit --workspace` die des Projekts. Jeder Schlüssel beginnt mit `amp.`:

```json
{
  "$schema": "https://ampcode.com/cli-settings.schema.json",
  "amp.showCosts": true,
  "amp.git.commit.coauthor.enabled": true,
  "amp.notifications.enabled": true
}
```

- `amp.showCosts` zeigt, was jeder Thread kostet.
- `amp.tools.disable` schaltet Tools per Name ab, auch mit `*`-Mustern; `amp tools list` listet die eingebauten.
- `amp.git.commit.ampThread.enabled` und `amp.git.commit.coauthor.enabled` steuern, was Amp an seine Commit-Nachrichten anhängt, etwa den Trailer `Amp-Thread-ID`, der einen Commit mit seinem Thread verknüpft.

Eins solltest du vorher wissen: Standardmäßig **fragt Amp vor dem Ausführen von Tools nicht nach Freigabe**. Arbeite auf einem Branch, committe oft und nutze `amp.tools.disable` oder ein Plugin, wenn du Grenzen setzen willst. Suchst du einen Agent, der standardmäßig erst fragt, sind Claude Code und Codex CLI um Freigabe-Abfragen herum gebaut.

Skills funktionieren, wie du es von anderen Agents kennst: ein Ordner mit einer `SKILL.md`. Amp lädt Projekt-Skills aus `.agents/skills/`, persönliche aus `~/.config/amp/skills/` und `~/.config/agents/skills/`, dazu die Claude-Code-Ordner `.claude/skills/` und `~/.claude/skills/`.

## Schritt 7: AGENTS.md

`AGENTS.md` enthält die Regeln eines Projekts: wie gebaut, getestet und gelintet wird, welche Konventionen gelten, welche Ordner tabu sind. Amp liest die Datei im aktuellen Ordner und in jedem übergeordneten Ordner bis zu deinem Home-Verzeichnis und bezieht sie immer ein. Eine `AGENTS.md` in einem Unterordner kommt dazu, sobald Amp dort eine Datei liest. Hat ein Projekt keine, bietet Amp an, eine zu schreiben.

```markdown
# Project rules

- Package manager: pnpm. Run `pnpm test` before you finish a task.
- TypeScript strict mode; no `any` in new code.
- API handlers live in src/api/; one file per route.
- See @docs/architecture.md for the module layout.
```

Ein paar Details, die sich lohnen:

- **@-Erwähnungen** ziehen weitere Dateien herein: relative Pfade, `@~/`-Pfade und Muster wie `@docs/*.md`.
- **Persönliche Regeln** kommen in `~/.config/amp/AGENTS.md` (oder `~/.config/AGENTS.md`).
- **Fallback:** In einem Ordner ohne `AGENTS.md` liest Amp `AGENT.md` oder `CLAUDE.md`, ein Claude-Code-Projekt funktioniert also ab dem ersten Tag.
- **Begrenzte Regeln:** Eine erwähnte Datei kann `globs:` im Frontmatter tragen, sodass ihre Vorgaben nur gelten, wenn Amp an passenden Dateien arbeitet.

Was in die Datei gehört, erklärt der Beitrag [CLAUDE.md und AGENTS.md schreiben](/de/blog/claude-md-agents-md/ "CLAUDE.md und AGENTS.md schreiben").

## Schritt 8: MCP-Server

[MCP-Server](/de/blog/what-is-mcp-server/ "Was ist ein MCP-Server") geben Amp neue Tools: einen Browser, einen Issue-Tracker, eine Doku-Suche. Am schnellsten fügst du einen über die CLI hinzu:

```bash
amp mcp add context7 -- npx -y @upstash/context7-mcp
amp mcp add linear https://mcp.linear.app/sse
```

Beide landen in deinen Einstellungen unter `amp.mcpServers`. Ein lokaler Server ist ein Befehl, ein entfernter eine URL, und `${VAR}` holt Werte aus der Umgebung:

```json
{
  "amp.mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest", "--headless"]
    },
    "linear": {
      "url": "https://mcp.linear.app/sse"
    }
  }
}
```

Server in der `.amp/settings.json` eines Workspace laufen erst, wenn du sie mit `amp mcp approve <name>` freigibst; `amp mcp doctor` zeigt den Zustand jedes Servers. Ist derselbe Server an mehreren Stellen definiert, gewinnt `--mcp-config` vor der Workspace-Datei und diese vor deinen Benutzereinstellungen. Weil jeder Server seine Tools in den Kontext lädt, empfiehlt die Doku, selten genutzte Server in einen Skill zu packen (mit einer `mcp.json`), damit ihre Tools nur geladen werden, wenn der Skill es wird.

## Schritt 9: Threads und Execute-Modus

Jeder Thread hat eine URL wie `https://ampcode.com/threads/T-…`. `amp threads continue T-…` setzt ihn im Terminal fort, `amp threads share T-… --visibility unlisted` macht ihn teilbar, und `@T-…` in einem Prompt holt einen anderen Thread als Kontext dazu. Threads, die du außerhalb eines Workspace startest, sind privat.

Für Skripte und CI führt der **Execute-Modus** einen Prompt aus und beendet sich:

```bash
amp -x "what package manager is used here?"
git diff | amp -x "review this diff for bugs"
amp -ox "Investigate why the latest CI run on main failed"
```

`-x` läuft auf deinem Rechner und schaltet sich von selbst ein, wenn die Ausgabe umgeleitet wird. `-ox` führt den Prompt stattdessen auf einem Orb aus. `--stream-json` liefert maschinenlesbare Ausgabe, und `--mcp-config` fügt MCP-Server nur für diesen einen Lauf hinzu.

## Was kostet Amp? (Stand Oktober 2026)

| Tarif | Preis | Was du bekommst |
| --- | --- | --- |
| Hobby | Kostenlos | Alle Produktfunktionen; Orbs nach Verbrauch; eigene Abos oder Keys |
| Individual (Megawatt) | 20 Dollar im Monat | Enthaltene Nutzung plus 45.000 Minuten Orb-Zeit auf Amps Servern |
| Teams | Ohne Aufpreis | Geteilte Threads, Skills und Abrechnung, gemeinsame Credits, SSO |
| Enterprise | Individuell | Admin-Kontrollen, Audit-Logs, Optionen zur Datenaufbewahrung |

Die Modellnutzung kommt aus einer von drei Quellen: einem verknüpften ChatGPT- oder Claude-Abo, deinen eigenen API-Keys oder Amp-Credits. Ist die enthaltene Nutzung aufgebraucht, kaufst du Credits nach; Amp rechnet sie zu den tatsächlichen Modell- und Tool-Kosten jedes Threads ab, für Einzelpersonen und Workspaces ohne Enterprise-Vertrag ohne Aufschlag auf die API-Preise der Anbieter. Für Credits brauchst du keinen bezahlten Tarif. Auch die Websuche verbraucht Credits. Credits verfallen zwölf Monate nach dem Kauf, und `amp usage` zeigt dein Guthaben. Orbs werden pro Minute abgerechnet und pausieren im Leerlauf; Runner auf deinem eigenen Rechner sind kostenlos.

## Typische Stolperfallen

- **Falscher Modus, und Strg+S ändert nichts.** Der Thread hat schon eine erste Nachricht. Starte mit Strg+C Strg+N einen neuen.
- **CI meldet eine ungültige Anmeldung.** Das Sitzungstoken von `amp login` ist kurzlebig. Setze `AMP_API_KEY` auf ein Zugriffstoken mit `sgamp_`.
- **Ein MCP-Server aus dem Workspace taucht nie auf.** Er braucht eine Freigabe: `amp mcp approve <name>`, danach mit `amp mcp doctor` prüfen.
- **Dein Claude-Plan wird nicht genutzt.** Nur der Claude-Code-Modus läuft darüber; `low` bis `ultra` nutzen Amps eigenes Routing.
- **Amp hat einen unerwarteten Befehl ausgeführt.** Standardmäßig fragt es nicht. Schalte das Tool ab oder arbeite auf einem Branch, den du wegwerfen kannst.
- **Shift+Enter schickt in tmux den Prompt ab.** Schalte `extended-keys` ein oder nimm Strg+J.

## Amp neben anderen CLIs in AgentVera betreiben

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

- **Deine Amp-Anmeldung.** Amp nutzt seine eigene ampcode.com-Anmeldung. Bist du abgemeldet, fragt das Terminal des Agents beim ersten Start danach. Unter Einstellungen → Konten → Konten anderer Agents kannst du weitere Amp-Konten hinzufügen, die mit API-Keys laufen, und jedem Agent eine geordnete Liste von Ersatzkonten geben.
- **Ein Thread pro Agent.** Für jeden Agent wird vorab mit `amp threads new` ein neuer Thread angelegt, und der Agent kehrt bei späteren Starts mit `threads continue` dorthin zurück.
- **Modi statt Modelle.** Du wählst für jeden Agent low, medium, high oder ultra, übergeben mit `--mode`.
- **MCP und der Browser.** Die Server aus AgentVeras [MCP-Manager](/de/features/mcp-manager/ "MCP-Manager") und AgentVeras Browser werden mit `--mcp-config` übergeben. Amp hat kein Flag für zusätzliche Anweisungen, daher wird das Rollenfeld des Agents nicht genutzt; stattdessen gilt deine `AGENTS.md`.
- **Panes, Worktrees, Review und Flows.** Lass Amp im [Workspace](/de/features/workspace/ "Workspace")-Raster neben anderen Agents laufen, jeden in seinem eigenen Git-Worktree, damit sie sich nicht gegenseitig überschreiben. Das automatische Code-Review prüft ihre Änderungen, und in Flows (Pro und Team) kann Amp Quell- oder Ziel-Agent sein.

Raster, Worktrees, Code-Review und MCP-Manager sind im kostenlosen Plan enthalten. Zum Ausprobieren: [AgentVera herunterladen](/de/download/ "AgentVera herunterladen").

## Fazit

Um Amp zu nutzen, installierst du die CLI, führst `amp login` aus, wählst mit Strg+S einen Modus und beschreibst die Aufgabe. Starte die meisten Threads mit `medium`, wechsle für schwierige zu `high` oder `ultra` und überlass Suche und Review den Subagents. Projektregeln gehören in `AGENTS.md`, Tools unter `amp.mcpServers`, und für Skripte nimmst du `AMP_API_KEY` mit `amp -x`. Weil Amp Tools ohne Rückfrage ausführt, halte es auf einem Branch, dann holst du das Beste aus einem Agent heraus, der dafür gebaut ist, einfach loszulegen.

## Häufige Fragen

**Ist Amp kostenlos?** Stand Oktober 2026 ist der Hobby-Tarif kostenlos und enthält alle Produktfunktionen. Die Modellnutzung bezahlst du über ein verknüpftes ChatGPT- oder Claude-Abo, eigene API-Keys oder Amp-Credits, die Amp für Einzelpersonen zu den API-Preisen der Anbieter ohne Aufschlag abrechnet. Der Individual-Tarif kostet 20 Dollar im Monat und bringt 45.000 Minuten Orb-Zeit auf Amps Servern mit.

**Wer entwickelt Amp heute?** Amp ist bei Sourcegraph entstanden. Im Dezember 2025 wurde es als eigenständiges Unternehmen ausgegründet; CLI, Web-App und Dokumentation liegen inzwischen auf ampcode.com.

**Kann ich in Amp das Modell wählen?** Nicht direkt pro Nachricht. Du wählst einen Modus (low, medium, high oder ultra), und der Modus bestimmt Modell, Reasoning-Aufwand, Prompt und Tools. Unter Einstellungen → Mode Dial → Tune Modes kannst du Modelle pro Modus festlegen und eigene API-Keys verwenden.

**Liest Amp CLAUDE.md?** Ja, als Fallback. In jedem Ordner ohne AGENTS.md liest Amp stattdessen AGENT.md oder CLAUDE.md. Außerdem lädt es Skills aus den Skill-Ordnern von Claude Code, .claude/skills/ und ~/.claude/skills/, sofern du das nicht abschaltest.

**Fragt Amp nach, bevor es Befehle ausführt?** Nein. Standardmäßig fragt Amp vor dem Ausführen von Tools nicht nach Freigabe. Du kannst eingebaute Tools mit amp.tools.disable abschalten, mit amp.mcpPermissions Regeln für MCP-Tools festlegen oder ein Plugin schreiben, das entscheidet, welche Tool-Aufrufe laufen.

---

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