# Zed Editor einrichten

> **Zuletzt überprüft**: 2026-09-18 · 📄 Laut offizieller Dokumentation (Zed Stable v1.20.2, veröffentlicht am 2026-09-17)

## Auf einen Blick

| Element | Details |
|---|---|
| Verfügbare Modelle | Claude ✅ (Route A: ACP / Route B: Anthropic-kompatibler Anbieter) · GPT ✅ (OpenAI-kompatibler Anbieter) · Chinesische Modelle ✅ (beide Anthropic-kompatiblen Routen) · Gemini ❌ (hier keine Gemini-Route dokumentiert) |
| Protokoll & Basis-URL | Anthropic: `https://api.qcode.cc/api` (Zed fügt `/v1/messages` hinzu, hier kein `/v1`) · OpenAI: `https://api.qcode.cc/openai/v1` (fügt `/chat/completions` hinzu) |
| Konfiguration | `~/.config/zed/settings.json` (macOS / Linux; Windows `%APPDATA%/Zed/settings.json`; Änderungen ohne Neustart wirksam) |
| Offizielle Dokumentation | [API-Zugriff nutzen](https://zed.dev/docs/ai/use-api-access) · [Zed konfigurieren](https://zed.dev/docs/configuring-zed)
[Zed](https://zed.dev) ist ein leistungsstarker, moderner Code-Editor in Rust, der seit Q1 2026 das [Agent Client Protocol (ACP)](https://github.com/agentclientprotocol/agent-client-protocol) nativ unterstützt – ein offener Standard, der die Kommunikation zwischen IDE und KI-Agent entkoppelt, ähnlich wie LSP dies für Sprachserver getan hat. Zed integriert Claude Agent (den `claude-agent-acp`-Wrapper für das Claude Agent SDK) über ACP und stellt ein Agent-Panel zur Orchestrierung mehrstufiger Coding-Aufgaben bereit. Diese Anleitung zeigt, wie Sie QCode.cc als Upstream für Claude Code in Zed konfigurieren und wie Sie QCode direkt als Anthropic-kompatiblen / OpenAI-kompatiblen Anbieter in Zeds `settings.json` hinzufügen.

QCode verwendet durchgehend einen einzigen API-Key (beginnt mit `cr_`). Derselbe Key unterstützt die Anthropic-, OpenAI-Chat-, OpenAI-Responses-, Gemini- und Bildprotokolle und wird auf drei Eingangsdomänen gemappt – `api` / `asia` / `us` (Nutzer in Festlandchina sollten `asia.qcode.cc` bevorzugen).

## Warum Zed

- **Native ACP-Integration**: Claude Code-Sitzungen im Agent-Panel öffnen und die Überlegungen sowie Tool-Aufrufe des Agenten live im Editor verfolgen
- **1M Kontext**: BYOK-Modus unterstützt das volle 1M-Token-Kontextfenster von Opus 5 / 4.8 / 4.7
- **Rust-Performance**: extrem schneller Kaltstart und ein um eine Größenordnung geringerer Speicherbedarf als VS Code / Electron-basierte Editoren
- **Multi-Pane-Layout**: Editor + Terminal + Agent-Panel nebeneinander für einen kompakten Workflow
- **Zwei Integrationswege**: Ausführung über die Claude Code CLI (volle Tool-Oberfläche) oder QCode als eingebauten Anbieter in `settings.json` hinzufügen

## Die zwei Integrationswege im Vergleich

Zed bietet zwei komplementäre Wege, QCode zu erreichen – wählen Sie je nach Bedarf:

| Weg | Beschreibung | Geeignet für |
|------|-------------|----------|
| **A. ACP / Claude Agent** (empfohlen) | Das Agent-Panel bindet Claude Agent über ACP ein und nutzt die Umgebungsvariablen-Konfiguration der CLI | Vollständige Hooks, Skills und MCP, gemeinsame Konfiguration mit dem Terminal-Workflow |
| **B. Anbieter in settings.json** | Basis-URL und Key direkt in den Zed-Einstellungen angeben, mit Zeds eingebautem HTTP-Client | Keine CLI-Installation erforderlich; reiner In-IDE-Assistent / Inline-Vervollständigung |

Der Abschnitt „Konfiguration“ unten behandelt Weg A; „Anbieter in settings.json konfigurieren“ behandelt Weg B.

## Voraussetzungen

- [Zed](https://zed.dev/download) installiert (macOS / Linux)
- [Claude Code CLI](/docs/getting-started/installation) installiert (Zeds ACP-Integration nutzt die CLI als Backend; überspringen Sie diesen Schritt, wenn Sie nur Weg B verwenden)
- Ein QCode.cc API-Key (beginnt mit `cr_`), verfügbar im [Dashboard](https://qcode.cc/dashboard)
- Claude Code CLI ist bereits mit QCode-Umgebungsvariablen konfiguriert (siehe [Schnellstart](/docs/getting-started/quick-start))

## Konfigurationsschritte (Pfad A: ACP / Claude Code)

### Schritt 1: Prüfen, ob die Claude Code CLI im Terminal funktioniert

Zed startet ACP, indem ein `claude`-Prozess erzeugt wird, daher prüfen Sie zuerst im Terminal, ob die CLI funktioniert:

```bash
export ANTHROPIC_BASE_URL="https://api.qcode.cc/api"
export ANTHROPIC_AUTH_TOKEN="cr_xxxxxxxx"
claude --version   # should print a version number (trust this machine + official Releases)
echo "ping" | claude   # simple echo test
```

> `ANTHROPIC_BASE_URL` darf **nicht** mit einem Schrägstrich enden; das Anthropic SDK hängt `/v1/messages` selbst an. Verankern Sie diese beiden Umgebungsvariablen dauerhaft in Ihrer Shell-Konfiguration (`~/.zshrc` / `~/.bashrc`), damit Zed sie beim Start erbt.

### Schritt 2: Das Agent-Panel in Zed öffnen

- macOS: `Cmd + ?`
- Linux: `Ctrl + ?`

Beim ersten Öffnen bittet Sie Zed, einen Agent-Anbieter auszuwählen — wählen Sie **Claude Code** (wählen Sie nicht BYOK Anthropic API; dieser Pfad umgeht die CLI und erfordert, dass Sie in den Zed-Einstellungen separat eine Basis-URL eintragen — siehe Pfad B).

### Schritt 3: Die Agent-Sitzung überprüfen

Geben Sie in die Eingabe des Agent-Panels ein: „List the exported symbols in the current file.“ Zed übergibt die aktuell geöffnete Datei als Kontext an Claude Code, und der Agent ruft die Tools `read` / `grep` auf, um zu analysieren und zu antworten.

Falls der Agent-Prozess nicht startet, kann der ACP-Agent-Befehl über `agent_servers.<name>.command / args / env` in `settings.json` explizit festgelegt werden (es gibt keinen Einstellungs-Schlüssel `agent.path`). Namen und Felder: richten Sie sich nach der offiziellen Dokumentation.

> Die Agent- / Assistant-Einstellungen von Zed ändern sich zwischen Releases schnell; für exakte Schlüsselnamen gilt die [offizielle Zed-Dokumentation](https://zed.dev/docs/ai/overview).

## Einen Anbieter in settings.json konfigurieren (Pfad B)

Wenn Sie die CLI lieber nicht installieren, fügen Sie QCode in `settings.json` hinzu — die JSON-Datei selbst öffnen Sie mit `Cmd+Alt+,` (`Ctrl+Alt+,` unter Linux; `Cmd+,` öffnet die Einstellungen-Benutzeroberfläche); sie liegt unter `~/.config/zed/settings.json` (Windows: `%APPDATA%/Zed/settings.json`) und wird ohne Neustart angewendet. Für Drittanbieter-Gateways sind die offiziell empfohlenen Einträge die benutzerdefinierten Anbieter **`anthropic_compatible` / `openai_compatible`**. QCode spricht beide Protokolle mit dem **gleichen `cr_`-Schlüssel**.

### Anthropic-kompatibler Anbieter

Richten Sie die Basis des in Zed integrierten Anthropic-Anbieters auf QCodes Anthropic-Endpunkt:

```json
{
  "language_models": {
    "anthropic_compatible": {
      "QCode": {
        "api_url": "https://api.qcode.cc/api"
      }
    }
  }
}
```

Stellen Sie den Schlüssel über eine Umgebungsvariable bereit (von Zed beim Start geerbt):

```bash
export QCODE_API_KEY="cr_xxxxxxxx"
```

> Das integrierte `language_models.anthropic.api_url` existiert ebenfalls und funktioniert, aber der in der Upstream-Dokumentation genannte Einstiegspunkt für Drittanbieter-Gateways ist der oben gezeigte `anthropic_compatible`-Anbieter. Die Basis-URL endet auf `/api` — **kein `/v1`** — Zed hängt `/v1/messages` selbst an. Platzieren Sie keine API-Keys in `settings.json` (offizielle Regel); verwenden Sie die generierte Variable `<PROVIDER_NAME>_API_KEY`.

### OpenAI-kompatibler Anbieter

Zed unterstützt auch einen OpenAI-kompatiblen Anbieter, der QCodes GPT-Modelle erreichen kann. Richten Sie die Basis auf QCodes OpenAI-Chat-Endpunkt:

```json
{
  "language_models": {
    "openai_compatible": {
      "QCodeOpenAI": {
        "api_url": "https://api.qcode.cc/openai/v1",
        "available_models": [
          { "name": "gpt-5.6-terra" },
          { "name": "gpt-5.6" },
          { "name": "glm-5.3" },
          { "name": "deepseek-v4-flash" }
        ]
      }
    }
  }
}
```

Der Schlüssel stammt ebenfalls aus einer Umgebungsvariable:

```bash
export QCODEOPENAI_API_KEY="cr_xxxxxxxx"
```

> Die OpenAI-Chat-Basis ist `https://api.qcode.cc/openai/v1` (das SDK hängt dann `/chat/completions` an). Kein abschließender Schrägstrich. Die Feldnamen in `available_models` (`name` / `max_tokens` usw.) sollten sich nach der offiziellen Zed-Dokumentation richten.
## Modellauswahl

Derselbe QCode-API-Key stellt Modelle mehrerer Anbieter bereit. Wechseln Sie bei Bedarf über das Modellauswahlmenü im Agent-Panel oder im Assistenten:

> **Welcher Anbieterpfad**: `claude-*` funktioniert nur beim Anthropic-Anbieter (`https://api.qcode.cc/api`); `gpt-*` funktioniert nur beim OpenAI-Anbieter (`https://api.qcode.cc/openai/v1`). Eine Mischung liefert `model_not_available_on_endpoint`.

| Modell | Einsatz |
|-------|---------|
| `claude-opus-5` | Flaggschiff – komplexe Reasoning-Aufgaben, große Refactorings |
| `claude-opus-4-7` | Flaggschiff-Alternative |
| `claude-sonnet-5` | Täglicher Coding-Allrounder, hervorragendes Preis-Leistungs-Verhältnis |
| `claude-haiku-4-5` | Schnelle Vervollständigung, leichtgewichtige Aufgaben |
| `gpt-6-sol` | GPT-Flaggschiff |
| `gpt-6-luna` | GPT leichtgewichtig, geringe Kosten |
| `gpt-5.6-terra` | Code-spezialisiert |

> Die obige Tabelle entspricht der aktuellen Empfehlung. 4.x-IDs wie `claude-sonnet-4-6`, `claude-opus-4-8` und `claude-opus-4-7` sind weiterhin erhältlich; die aktuelle Liste finden Sie unter [qcode.cc/models](https://qcode.cc/models).

- Bei Pfad A (Claude Code) wird das Modell durch die Konfiguration von Claude Code selbst bestimmt (Wechsel über `/model` oder setzen von `ANTHROPIC_MODEL`).
- Bei Pfad B mit dem Anthropic-Anbieter verwenden Sie `claude-*`-Modell-IDs; beim OpenAI-Anbieter `gpt-*`-Modell-IDs.
- Die Gemini- und Bildprotokolle (`gpt-image-2`) sind im Zed-Assistenten nicht unbedingt nativ verfügbar; rufen Sie sie direkt über die CLI / Skripte auf – siehe [Endpunkte und API-Pfade](/docs/getting-started/endpoints-and-api-paths) und [gpt-image-2 Bildgenerierung](/docs/usage/image-2).

## Nutzungsbeispiele

### Agent-Panel: Dateiübergreifende Aufgaben

Das Agent-Panel spielt seine Stärken bei mehrstufigen, dateiübergreifenden Aufgaben aus. Beispiel:

> „Konvertieren Sie alle synchronen IO-Aufrufe unter `utils/` zu async und aktualisieren Sie die Aufrufer.“

Das Agent verwendet `grep` zum Auffinden, `read` zum Prüfen und `edit` zum Ändern und zeigt die Diffs Schritt für Schritt im Editor an, sodass Sie jeden einzelnen Diff akzeptieren / ablehnen können.

### Screenshots für das Agent-Panel bereitstellen (Vision-Eingabe)

Claude Opus 5 / Sonnet 5 und GPT-5.x sind alle vision-fähig. Sie können UI-Mockups, Fehler-Screenshots oder Architekturdiagramme als **Eingabe** an das Agent übergeben:

- Bild einfügen (`Ctrl+V`) oder per Drag-and-Drop in die Eingabezeile des Agent-Panels ziehen
- Alternativ einen lokalen Bilddateipfad in Ihrer Eingabeaufforderung referenzieren

Typische Anwendungsfälle: UI aus einem Mockup erstellen, Debugging anhand eines Fehler-Screenshots, Architekturdiagramme / Charts lesen.

> Hinweis: Hier geht es um das **Bereitstellen** von Bildern für das Modell (Vision-Eingabe), nicht um das **Generieren** von Bildern. Verwenden Sie zum Generieren von Bildern `gpt-image-2` – siehe [gpt-image-2 Bildgenerierung](/docs/usage/image-2).

### Dynamische Workflows (Orchestrierung von Hintergrund-Sub-Agents)

Claude Code unterstützt Dynamische Workflows: Orchestrieren Sie Dutzende bis Hunderte von Hintergrund-Sub-Agents, ideal für codebase-weite Reviews, Migrationen und Rechercheaufgaben. Auslösen, indem Sie das Schlüsselwort `ultracode` in Ihre Eingabeaufforderung aufnehmen oder einfach „run a workflow“ anfordern; aktive Läufe anzeigen über den Befehl `/workflows`. Sub-Agents laufen im Hintergrund weiter, während Sie andere Aufgaben erledigen. Der Workflow verwendet das Modell, das in Claude Code konfiguriert ist – er funktioniert also auch, wenn Claude Code auf QCode zeigt. Weiterführende Informationen: [Subagents](/docs/advanced/subagents).

### Headless / Automations-Ausgabeformate

Wenn Sie Claude Code in CI / Skripten aufrufen, verwenden Sie `claude -p` mit `--output-format`:

```bash
# JSON: one structured object with result / total_cost_usd / usage / session_id
claude -p "Summarize this change" --output-format json | jq .result

# stream-json: newline-delimited JSON event stream, good for real-time pipelines
claude -p "Refactor this module" --output-format stream-json

# text: plain text (default)
claude -p "Explain this code" --output-format text
```

Weitere Verwendungsmöglichkeiten finden Sie unter [Automatisierung & CI/CD](/docs/advanced/headless).
## Fallback-Endpunkte

Ist der primäre Endpunkt nicht erreichbar, wechseln Sie `ANTHROPIC_BASE_URL` (oder `api_url` in settings.json):

| Endpunkt | Anthropic Base URL |
|----------|--------------------|
| Global | `https://api.qcode.cc/api` |
| Nordamerika / Europa | `https://us.qcode.cc/api` |
| Asien (empfohlen für Nutzer in China) | `https://asia.qcode.cc/api` |

Für den OpenAI-kompatiblen Pfad tauschen Sie die Domain auf dieselbe Weise – z. B. lautet die Asien-OpenAI-Chat-Basis-URL `https://asia.qcode.cc/openai/v1`. Die vollständige Endpunkt-Referenz finden Sie unter [Endpunkte und API-Pfade](/docs/getting-started/endpoints-and-api-paths).

## Gemeinsames Kontingent

Der Claude Code Agent in Zed nutzt denselben QCode API-Key und dasselbe Kontingent wie die CLI / Claude Desktop / Codex CLI – es erfolgt keine doppelte Abrechnung. Pfad A und Pfad B teilen sich ebenfalls dasselbe Kontingent des Keys. Details finden Sie unter [Abrechnung](/docs/reference/billing).

## Einschränkungen und Hinweise

- **Zeds BYOK-Anthropic-Direktmodus** nutzt Zeds integrierten Anthropic-Anbieter und **läuft nicht über die Claude Code CLI**. Dafür müssen Sie `api_url` in den Zed-Einstellungen manuell auf QCode setzen (Pfad B). Der hier beschriebene ACP-/Claude-Code-Modus (Pfad A) wird bevorzugt – er erhält die volle CLI-Tool-Oberfläche (Hooks, Skills, MCP).
- **Die Basis-URL darf keinen abschließenden Schrägstrich enthalten.** Eine Self-Check-Anfrage an einen Basispfad gibt `401` zurück, was erwartet wird (der Pfad ist korrekt, es fehlt lediglich die Authentifizierung).
- Die ACP-Integration befindet sich in der Public Beta (seit 2026-04); einzelne APIs können sich noch ändern. Bei Abweichungen im Verhalten ist die [offizielle Zed-Dokumentation](https://zed.dev/docs/ai/models) maßgeblich.
- Linux-Sandbox-Nutzer: Ist Zed über Flatpak installiert, kann das Starten des `claude`-Subprozesses durch die Sandbox blockiert werden. Wir empfehlen, direkt den .deb- / AppImage- / Homebrew-Build zu installieren.
- Die Gemini CLI wurde eingestellt (EOL 2026-06-18 für Pro/Free; Enterprise-bezahlte Keys sind nicht betroffen); ihr Nachfolger ist die Google Antigravity CLI. **Hinweis: Die Antigravity CLI akzeptiert ausschließlich einen Gemini-kompatiblen Endpunkt** (über `GOOGLE_GEMINI_BASE_URL`), keinen OpenAI-kompatiblen – siehe [Antigravity CLI](/docs/ide/antigravity).

## FAQ

### Agent-Panel meldet „Failed to start agent“

- Startet `claude` korrekt in Ihrem Terminal? Schließen Sie zunächst Konfigurationsprobleme auf CLI-Seite aus.
- Hat Zed die `ANTHROPIC_*`-Umgebungsvariablen geerbt? Unter macOS gewährleisten Sie die Vererbung, wenn Sie Zed über `open -a Zed` vom Terminal aus starten.
- Zeigt `agent.path` in Ihren Einstellungen auf einen gültigen Pfad? Prüfen Sie dies mit `which claude`.

### settings.json-Provider liefert 401 / Authentifizierungsfehler

- Stellen Sie sicher, dass die richtige Umgebungsvariable gesetzt ist und einen `cr_`-präfixierten QCode-Key enthält: Benutzerdefinierte Anbieter verwenden `<PROVIDER_NAME>_API_KEY` (z. B. `QCODE_API_KEY` / `QCODEOPENAI_API_KEY`); nur integrierte Anbieter verwenden `ANTHROPIC_API_KEY` / `OPENAI_API_KEY`.
- Hat Zed diese Umgebungsvariable geerbt? Starten Sie Zed vom Terminal aus, um dies zu überprüfen.
- Enthält `api_url` versehentlich einen abschließenden Schrägstrich? Entfernen Sie ihn.

### Das gewünschte Modell ist nicht im Dropdown enthalten

- Der OpenAI-Provider von Pfad B erfordert, dass Modelle explizit in `available_models` aufgeführt sind, bevor sie im Dropdown erscheinen.
- Die verfügbaren Modelle von Pfad A werden durch Claude Code bestimmt; verwenden Sie `/model`, um sie anzuzeigen und zu wechseln.

### „Invalid model“ / 404

- Überprüfen Sie erneut, ob die Schreibweise der Modell-ID exakt mit der Tabelle übereinstimmt (z. B. `claude-opus-5`, `gpt-6-luna`).
- Stellen Sie sicher, dass das Protokoll der Basis-URL zum Modell passt: `claude-*` verwendet den Anthropic-Endpunkt, `gpt-*` den OpenAI-Endpunkt.

### Unterschied zum BYOK-Anthropic-Modus

| Dimension | ACP-/Claude-Code-Modus (Pfad A) | Zed-BYOK-Anbietermodus (Pfad B) |
|-----------|---------------------------------|---------------------------------|
| Backend | startet den `claude`-CLI-Subprozess | Zeds integrierter HTTP-Client |
| Tool-Unterstützung | vollständig (alle CLI-Hooks / Skills / MCP) | durch Zeds integriertes Agent-Framework eingeschränkt |
| Konfigurationsspeicherort | Claude Code CLI Umgebungsvariablen | Zed-Einstellung `language_models.*.api_url` |
| Modellumfang | in Claude Code konfigurierte Modelle | die in settings.json aufgelisteten Anthropic-/OpenAI-Modelle |
| Empfohlen für | gemeinsame Konfiguration mit dem Terminal-CLI-Workflow | Nutzer, die die CLI nicht installieren möchten und reine IDE-Integration bevorzugen |

## Nächste Schritte

- [Claude Code Tutorial](/docs/getting-started/claude-code-tutorial) – vollständige CLI-Funktionsreferenz
- [Endpunkte und API-Pfade](/docs/getting-started/endpoints-and-api-paths) – vollständige Referenz aller drei Ingress-Domains
- [Subagents](/docs/advanced/subagents) – Dynamic Workflows und Multi-Agent-Orchestrierung
- [Automatisierung & CI/CD](/docs/advanced/headless) – Headless-Modus und Ausgabeformate
- [gpt-image-2 Bildgenerierung](/docs/usage/image-2) – Bildgenerierung (unterschiedlich zu Vision-Eingabe)
- [VS Code Integration](/docs/ide/vscode) – Vergleich mit Electron-basierten Editoren
- [Abrechnung](/docs/reference/billing) – Regeln zum gemeinsamen Kontingent

> Aktuelle Preise und Kontextspezifikationen für jedes Modell finden Sie auf der [QCode-Preisseite](https://qcode.cc/pricing).