# GitHub Copilot CLI vs Claude Code: Vergleich 2026

URL: https://agentvera.dev/de/blog/copilot-cli-vs-claude-code/ · Veröffentlicht: 2026-10-24

GitHub Copilot CLI vs Claude Code: Tarife und Preise, Modelle, Effort, Berechtigungen und Sandbox, Sitzungen, MCP und Installation, plus beide zusammen in AgentVera.

**Kurz gesagt:**

- Copilot CLI braucht ein GitHub-Copilot-Abo und bietet Modelle mehrerer Anbieter, darunter Claude; Claude Code braucht einen Claude-Tarif oder API-Account und nutzt Claude-Modelle.
- Beide CLIs nehmen eine Effort-Stufe bis max, setzen Sitzungen mit --resume fort und lesen CLAUDE.md, sodass ein Repo beide bedienen kann.
- Copilot CLI bringt einen eingebauten GitHub-MCP-Server und einen Autopilot-Modus mit; Claude Code ergänzt Berechtigungsmodi, Hooks, Skills und Subagenten.

**GitHub Copilot CLI vs Claude Code ist die Wahl zwischen einem Multi-Anbieter-Agenten, der an deinen GitHub-Tarif gebunden ist, und einem reinen Claude-Agenten mit tieferen Kontrollen.** Copilot CLI ist der Terminal-Agent von GitHub: Du meldest dich mit GitHub an, er nutzt dein Copilot-Abo und lässt dich Modelle mehrerer Anbieter wählen, Claude eingeschlossen. Claude Code kommt von Anthropic: Du meldest dich mit einem Claude-Tarif oder einem API-Account an, es nutzt Claude-Modelle und ergänzt Berechtigungsmodi, Hooks, Skills und Subagenten. Beide nehmen eine Effort-Stufe, setzen Sitzungen mit `--resume` fort, verbinden sich mit MCP-Servern und lesen `CLAUDE.md`.

Dieser Beitrag vergleicht Anmeldung und Preise, Modelle, Effort, Berechtigungen und Sandboxing, Sitzungen fortsetzen, MCP und Installation und zeigt dann, wie du beide nebeneinander betreibst. Keine Benchmark-Werte; mit Copilot kannst du in beiden dasselbe Claude-Modell nutzen, der Unterschied liegt also vor allem im Werkzeug drumherum.

## Copilot CLI und Claude Code im Überblick

| | GitHub Copilot CLI | Claude Code |
| --- | --- | --- |
| Hersteller | GitHub | Anthropic |
| Befehl | `copilot` | `claude` |
| Anmeldung | GitHub-Account (`copilot login`, `/login`) | Claude-Account oder Console-Account (API) |
| Nötiger Tarif | Aktives Copilot-Abo | Pro, Max, Team, Enterprise oder Console |
| Modelle | Mehrere Anbieter (Anthropic, OpenAI, Google und mehr), `auto` | Claude-Modelle (Aliase `sonnet`, `opus`, `haiku`) |
| Effort | `--effort` low, medium, high, xhigh, max | `--effort` low, medium, high, xhigh, max (modellabhängig) |
| Modi | interactive, plan, autopilot | default, acceptEdits, plan, auto, dontAsk, bypassPermissions |
| Tool-Regeln | `--allow-tool`, `--deny-tool`, `/permissions` | Berechtigungsregeln, Hooks |
| Sandbox | `/sandbox enable` | Eingebautes Sandboxing (macOS, Linux, WSL2) |
| Fortsetzen | `--resume`, `--continue`, `/resume` | `-c`, `-r`, `--fork-session` |
| Anweisungen | Führt `CLAUDE.md`, `AGENTS.md`, `.github/copilot-instructions.md` und mehr zusammen | `CLAUDE.md` |
| MCP | Eingebauter GitHub-MCP-Server, `~/.copilot/mcp-config.json`, `.mcp.json` | `claude mcp`, `.mcp.json` |

## Anmeldung und Preise

### Copilot CLI

Copilot CLI meldet sich über `copilot login` oder `/login` in einer Sitzung mit deinem GitHub-Account an und braucht ein aktives Copilot-Abo. Bist du in einem Firmentarif, kann ein Admin die CLI für die Organisation abschalten.

Zum Zeitpunkt des Schreibens (Oktober 2026) führt GitHub Copilot Free (0 $, begrenzte Nutzung), Pro (10 $/Monat), Pro+ (39 $/Monat), Max (100 $/Monat) sowie Business und Enterprise für Organisationen. Die Nutzung wird in GitHub AI Credits abgerechnet, aus denen auch die CLI schöpft; bezahlte private Tarife können zusätzliche Credits kaufen. Aktuelle Details stehen auf der [Copilot-Tarifseite von GitHub](https://github.com/features/copilot/plans "GitHub Copilot plans").

### Claude Code

Claude Code braucht einen Claude-Tarif Pro, Max, Team oder Enterprise oder einen Console-Account (API); der kostenlose Claude-Tarif enthält es nicht. Es kann auch über Amazon Bedrock, Google Cloud und Microsoft Foundry laufen.

Zum Zeitpunkt des Schreibens (Oktober 2026) führt Anthropic Pro mit 17 $/Monat bei jährlicher Zahlung oder 20 $ monatlich, Max ab 100 $/Monat und Team-Standardplätze mit 20 $ pro Platz und Monat bei jährlicher Zahlung oder 25 $ monatlich. Die Nutzungslimits setzen sich in 5-Stunden-Fenstern mit einer Wochenobergrenze zurück; siehe [Claude Code Nutzungslimits](/de/blog/claude-code-usage-limits/ "Claude Code Nutzungslimits"). Aktuelle Preise stehen auf der [Preisseite von Anthropic](https://claude.com/pricing "Claude pricing").

## Modelle und Effort

Copilots großer Vorteil ist die Auswahl. `--model` (oder `/model` innerhalb einer Sitzung) wählt ein Modell von Anthropic, OpenAI, Google und anderen Anbietern, und `auto` lässt Copilot entscheiden. `--effort` (auch `--reasoning-effort`) nimmt low, medium, high, xhigh oder max.

Claude Code nutzt nur Claude-Modelle. `--model` nimmt Aliase wie `sonnet`, `opus` und `haiku` oder einen vollständigen Modellnamen, und `--effort` nimmt low, medium, high, xhigh oder max, je nachdem, was das Modell unterstützt. Willst du nur Claude-Modelle, bietet dir Claude Code die meisten Funktionen drumherum; willst du pro Aufgabe den Anbieter wechseln, schafft Copilot das in einem Tool.

## Berechtigungen, Modi und Sandbox

### Copilot CLI

- **Modi:** `--mode interactive`, `plan` oder `autopilot`; auch `--plan`, `/plan` und `/autopilot` wechseln, und Shift+Tab schaltet durch. Autopilot arbeitet weiter, ohne bei jedem Schritt anzuhalten.
- **Tool-Regeln:** `--allow-tool` und `--deny-tool` erlauben oder sperren bestimmte Tools, und ein Deny gewinnt immer. `--allow-all-tools` genehmigt jedes Tool; `--allow-all` (oder `--yolo`) genehmigt alles.
- **Voreinstellungen:** `/permissions default`, `assisted` oder `allow-all` ändern die Stufe in einer laufenden Sitzung.
- **Sandbox:** `/sandbox enable` schaltet eine lokale Sandbox ein, die Dateisystem- und Netzwerkzugriff einschränkt.
- **Vertrauenswürdige Verzeichnisse:** Copilot fragt, bevor es in einem Ordner arbeitet, dem du nicht vertraut hast.

### Claude Code

- **Berechtigungsmodi:** `--permission-mode` nimmt `default` (fragt), `acceptEdits`, `plan`, `auto`, `dontAsk` oder `bypassPermissions`. `--dangerously-skip-permissions` überspringt jede Rückfrage.
- **Regeln und Hooks:** Allow- und Deny-Regeln in den Einstellungen sowie [Hooks](/de/blog/claude-code-hooks-guide/ "Claude Code Hooks Anleitung"), die eigene Skripte vor oder nach Tool-Aufrufen ausführen.
- **Sandbox:** eingebautes Sandboxing unter macOS, Linux und WSL2; nicht unter nativem Windows.

Alle Rückfragen zu überspringen ist in beiden riskant. Hebe das für einen isolierten Ordner oder Container auf; [Sicherheit bei KI-Coding-Agenten](/de/blog/ai-coding-agent-security/ "Sicherheit bei KI-Coding-Agenten") erklärt, warum.

## Sitzungen fortsetzen

- **Copilot CLI:** `copilot --resume` öffnet eine Auswahl, `--resume=ID` oder ein Sitzungsname wählt eine aus, `--continue` nimmt die letzte, und `/resume` funktioniert innerhalb einer Sitzung. `-n` benennt eine Sitzung und `--session-id` setzt ihre ID.
- **Claude Code:** `claude -c` setzt die letzte Sitzung im Ordner fort, `claude -r` nimmt per ID oder Name wieder auf, `--session-id` setzt die ID, und `--fork-session` startet aus einer fortgesetzten Sitzung einen neuen Zweig.

Beide haben `/compact`, um ein langes Gespräch zu verkürzen.

## Anweisungen und MCP

Hier passen die beiden ungewöhnlich gut zusammen. Copilot CLI führt benutzerdefinierte Anweisungen aus **`CLAUDE.md`**, `GEMINI.md`, `AGENTS.md`, `.github/copilot-instructions.md`, `.github/instructions/**/*.instructions.md` und `.claude/rules/**/*.md` zusammen. Ein für Claude Code eingerichtetes Repo gibt Copilot seine Regeln ohne Zusatzaufwand.

Für [MCP](/de/blog/what-is-mcp-server/ "Was ist ein MCP-Server?") bringt Copilot CLI einen eingebauten GitHub-MCP-Server mit, sodass Issues, Pull Requests und Repos von Anfang an da sind (`--disable-builtin-mcps` schaltet ihn ab). Server fügst du mit `/mcp add` oder `copilot mcp` hinzu, sie liegen in `~/.copilot/mcp-config.json`, und Copilot liest außerdem die `.mcp.json` eines Repos. Claude Code verwaltet Server mit `claude mcp` und nutzt dieselbe `.mcp.json` für projektbezogene Server, sodass eine Datei beide bedienen kann.

## Installation

```bash
# GitHub Copilot CLI
npm install -g @github/copilot          # Node 22+
brew install --cask copilot-cli
winget install GitHub.Copilot
curl -fsSL https://gh.io/copilot-install | bash

# Claude Code
curl -fsSL https://claude.ai/install.sh | bash
brew install --cask claude-code
winget install Anthropic.ClaudeCode
```

Unter Windows lässt sich Claude Code auch aus PowerShell installieren: `irm https://claude.ai/install.ps1 | iex`.

## Stärken, ehrlich

**Copilot CLI** ist am stärksten, wenn dein Team auf GitHub lebt und ohnehin für Copilot zahlt: eine Rechnung, Modelle mehrerer Anbieter, der GitHub-MCP-Server eingebaut und praktische Befehle wie `/review`, `/delegate` und `/fleet`. Autopilot-Modus und Allow- und Deny-Regeln für Tools machen es leicht festzulegen, wie viel er allein erledigt.

**Claude Code** ist am stärksten, wenn du die tiefste Kontrolle über ein Claude-Modell willst: sechs Berechtigungsmodi, Hooks, Skills, [Subagenten](/de/blog/claude-code-subagents/ "Claude Code Subagenten"), Sitzungs-Forking und ein großes Ökosystem rund um `CLAUDE.md`. Seine Grenze: Es ist nur Claude und braucht einen Claude-Tarif oder API-Account.

## Copilot CLI und Claude Code in AgentVera

AgentVera ist eine Desktop-App für macOS, Windows und Linux, die 18 Terminal-Coding-Agent-CLIs nebeneinander in echten Terminals ausführt, in einem Raster pro Projekt, mit deinen vorhandenen Logins. [GitHub Copilot CLI](/de/agents/copilot-cli/ "GitHub Copilot CLI in AgentVera") und [Claude Code](/de/agents/claude-code/ "Claude Code in AgentVera") stehen beide im Dialog “New agent”.

| Bedarf | In AgentVera |
| --- | --- |
| Anmeldung | Copilot nutzt sein eigenes GitHub-Login; bist du abgemeldet, führe `/login` in seinem Terminal aus. Claude Code nutzt dein vorhandenes Login, und jeder hinzugefügte Account bekommt ein eigenes `CLAUDE_CONFIG_DIR` |
| Modell wählen | Copilot: leer lassen für den Standard oder eines wählen, übergeben mit `--model`. Claude Code: Modelle aus seinem lokalen Katalog, plus Fast mode |
| Effort | Copilot: minimal bis max, übergeben mit `--reasoning-effort`. Claude Code: Auto, low bis max auf einem Regler |
| Rolle und Anweisungen | Copilot: als zusätzlicher Anweisungsordner (`AGENTS.md`) hinzugefügt, deine eigenen Anweisungen bleiben. Claude Code: `--append-system-prompt` |
| Berechtigungen | Ask, Auto oder Full access pro Agent, begrenzt auf die Stufen, die jede CLI unterstützt |
| Sitzungen behalten | Beide starten mit eigener `--session-id` und öffnen mit `--resume` erneut; Claude Code kann auch mit `--fork-session` verzweigen |
| Gemeinsame Tools | Die [MCP-Server](/de/features/mcp-manager/ "MCP-Manager") von AgentVera werden bei jedem Start angehängt; bei Copilot mit `--additional-mcp-config` |
| Arbeit prüfen | [Automatisches Code-Review](/de/features/code-review/ "Automatisches Code-Review") am Ende jedes Turns |
| Agenten verketten | [Flows](/de/features/flows/ "Flows"): jeder von beiden kann Quelle oder Ziel sein (Pro und Team) |

Das automatische Code-Review passt natürlich zu diesem Paar. Wenn ein Turn endet, prüft das von dir gewählte Claude-Modell die Commits dieses Turns oder alle Änderungen und listet die Befunde nach Schweregrad mit Datei und Zeile. Schaltest du es ein, gehen die Befunde für bis zu zwei Korrekturrunden zurück an den Agenten. So kann Copilot mit dem gewählten Modell schreiben, und ein Claude-Modell prüft das Ergebnis.

Mit einem Flow kommst du weiter: Wenn Copilot seinen Turn beendet, geht seine letzte Antwort in deine Vorlage (`{{output}}`, `{{source}}`, `{{target}}`) und wird an Claude Code gesendet, das bei Beschäftigung wartet, bis es dran ist. Ein Turn-Limit stoppt die Schleife, und ein Human-approval-Knoten kann für dich pausieren, auch auf Telegram. Copilot funktioniert außerdem in Broadcasts und geplanten Aufgaben und unterstützt `/compact`.

Claude Code bekommt die Extras, die nur manche CLIs unterstützen: [Account-Wechsel](/de/features/account-switching/ "Account-Wechsel") mit Account-Ketten, die weiterziehen, wenn das 5-Stunden- oder Wochenlimit aufgebraucht ist (Pro und Team), Kontextprofile, automatisches `/compact`, Remote Control und den Betrieb in Docker. Account-Wechsel ist für Copilot nicht verfügbar.

### Ein einfaches Setup

1. Halte deine Regeln in `CLAUDE.md` (oder `AGENTS.md`, daraus importiert); Copilot liest beide.
2. Öffne einen Copilot-CLI-Agenten und einen Claude-Code-Agenten im selben Projekt, jeden in einem eigenen [Git-Worktree](/de/blog/git-worktree-parallel-agents/ "Git-Worktrees für parallele Agenten").
3. Registriere deine MCP-Server einmal in AgentVera, damit beide sie bekommen.
4. Schalte das automatische Code-Review in den Projekteinstellungen ein.
5. In Pro oder Team fügst du einen Flow von einem Agenten zum anderen mit einem Review-Prompt und einem Turn-Limit hinzu.

Das Raster, Worktrees, Code-Review und der MCP-Manager sind im kostenlosen Tarif enthalten. [Lade AgentVera herunter](/de/download/ "AgentVera herunterladen") und probiere beide an deinem eigenen Repo aus. Weitere Paarungen findest du in [Claude Code vs Codex](/de/blog/claude-code-vs-codex/ "Claude Code vs Codex") und [den besten KI-Coding-CLI-Tools](/de/blog/best-ai-coding-cli-tools/ "Die besten KI-Coding-CLI-Tools").

## Was du wählen solltest

Nimm **Copilot CLI**, wenn du ohnehin für GitHub Copilot zahlst, zwischen Modellen mehrerer Anbieter wechseln willst und GitHub eingebaut magst. Nimm **Claude Code**, wenn du hauptsächlich mit Claude-Modellen arbeitest und Berechtigungsmodi, Hooks, Skills und Subagenten willst. Da Copilot `CLAUDE.md` liest, kostet es dich fast keinen Aufwand, beide am selben Repo auszuprobieren.

## Häufige Fragen

**Brauche ich für Copilot CLI oder Claude Code einen bezahlten Tarif?** Copilot CLI braucht ein aktives GitHub-Copilot-Abo; zum Zeitpunkt des Schreibens (Oktober 2026) führt GitHub die Tarife Free, Pro, Pro+ und Max sowie Business und Enterprise, abgerechnet in GitHub AI Credits. Claude Code ist im kostenlosen Claude-Tarif nicht enthalten; es braucht Pro, Max, Team, Enterprise oder einen Console-Account (API).

**Kann Copilot CLI Claude-Modelle nutzen?** Ja. Copilot bietet Modelle mehrerer Anbieter, darunter Anthropic, OpenAI und Google, und du wählst eines mit `--model` oder `/model`. Claude Code nutzt nur Claude-Modelle, bietet dir aber den vollen Claude-Code-Funktionsumfang drumherum.

**Liest Copilot CLI die CLAUDE.md?** Ja. Copilot CLI führt benutzerdefinierte Anweisungen unter anderem aus `CLAUDE.md`, `GEMINI.md`, `AGENTS.md`, `.github/copilot-instructions.md` und `.github/instructions/**/*.instructions.md` zusammen. Ein für Claude Code eingerichtetes Repo gibt Copilot CLI also bereits seine Regeln.

**Wie setze ich in beiden eine Sitzung fort?** Beide nutzen `--resume`. In Copilot CLI öffnet `copilot --resume` eine Auswahl, `--resume=ID` oder ein Sitzungsname wählt eine aus und `--continue` nimmt die letzte. In Claude Code setzt `claude -c` die letzte Sitzung fort, `claude -r` nimmt eine per ID oder Name wieder auf, und `--fork-session` zweigt sie ab.

**Kann ich Copilot CLI und Claude Code nebeneinander betreiben?** Ja. In AgentVera läuft jeder Agent in einem eigenen echten Terminal in einem Raster pro Projekt mit eigenem Login, idealerweise in einem eigenen Git-Worktree. Das automatische Code-Review prüft jeden Turn, und ein Flow kann die letzte Antwort eines Agenten an den anderen weitergeben (Flows gibt es in Pro und Team).

---

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