OpenCode einrichten: 12 Schritte, 45 Minuten [2026]

Wer täglich mit mehreren KI-Modellen gleichzeitig arbeitet, kennt das Problem: Jedes Tool bindet an einen Anbieter, jeder Wechsel kostet eine neue Lizenz. OpenCode löst das anders. Der offene, terminalbasierte Coding-Agent verbindet sich mit praktisch jedem Sprachmodell, von OpenAI über Anthropic bis zu offenen Gewichten wie Kimi K3, und bleibt dabei unter MIT-Lizenz komplett quelloffen. Diese Anleitung zeigt in zwölf Schritten, wie die Einrichtung in rund 45 Minuten gelingt, welche Provider sich lohnen und wo die typischen Stolperfallen liegen. Am Ende steht ein komplett funktionsfähiges Beispielprojekt, an dem sich jeder einzelne Schritt noch einmal im Zusammenhang nachvollziehen lässt. Mehr Hintergrund zu KI-Agenten und Sprachmodellen findet sich im KI-Ressourcenbereich von shattered.io.

Was ist OpenCode? Der offene KI-Coding-Agent im Überblick

Die offizielle Dokumentation beschreibt das Projekt schlicht als “an open source AI coding agent”, verfügbar als Terminal-Oberfläche, Desktop-App oder IDE-Erweiterung. Das Projekt lag ursprünglich unter dem Namen sst/opencode auf GitHub, ist inzwischen aber unter dem Repository anomalyco/opencode weitergeführt und wird dort aktiv gepflegt. Laut dem Analyse-Dienst inspect.software zählte das Repository im August 2026 bereits mehr als 193.000 Sterne und über 24.700 Forks, ein deutliches Zeichen dafür, wie schnell sich die Community um das Werkzeug herum gebildet hat. Aktuell liegt die Version v1.18.32 vor, laut GitHub als “Latest” markiert und zuletzt zwischen dem 21. und 23. September 2026 aktualisiert.

Der Kern des Konzepts ist Modell-Unabhängigkeit. Statt sich auf einen einzigen Anbieter festzulegen, greift OpenCode auf die Provider-Liste von Models.dev zurück und lässt Nutzer frei wählen, welches Sprachmodell eine Aufgabe übernimmt. Das reicht von kommerziellen APIs über OpenAI-kompatible Endpunkte bis zu Googles Vertex AI. Neuere Integrationen zeigen die Richtung: Erst im September 2026 kam laut AWS-Berichten eine native Amazon-Bedrock-Anbindung über die Converse API hinzu, wodurch sich auch Modelle wie das am 16. Juli 2026 veröffentlichte Kimi K3 mit seinem 1-Million-Token-Kontextfenster direkt aus OpenCode heraus nutzen lassen.

Technisch setzt OpenCode auf eine textbasierte Oberfläche (TUI), die im Terminal läuft, unterstützt aber laut eigener Dokumentation auch einen Desktop-Modus und einen Web-Zugriff über einen lokal gestarteten Server. Wer lieber mit einer grafischen Oberfläche arbeitet, findet über die separate Komponente “OpenCode Desktop” einen alternativen Einstieg, der Kern bleibt aber derselbe: ein einzelner Agent, der Dateien liest, Code schreibt, Befehle ausführt und dabei über das Model Context Protocol (MCP) zusätzliche Werkzeuge anbinden kann. MCP ist ein offener Standard, der es KI-Anwendungen erlaubt, sich über eine gemeinsame Schnittstelle mit externen Tools, Datenquellen und Diensten zu verbinden, mehr dazu im Abschnitt zu MCP-Servern weiter unten.

Von einem reinen Nischenprojekt ist OpenCode inzwischen weit entfernt. Laut aktuellen Daten von DataForSEO liegt das monatliche Suchvolumen für den Begriff “OpenCode AI” in Deutschland bei rund 1.000 Anfragen, mit einem Anstieg von 233 Prozent im Jahresvergleich und weiterhin niedriger Wettbewerbsintensität. Noch deutlicher zeigt sich der Trend beim hauseigenen Abo-Modell: Die Suchanfragen zu “OpenCode Go” kletterten von nur 10 im Januar 2026 auf über 12.100 im August 2026, ein Hinweis darauf, wie schnell sich das Werkzeug unter Entwicklerinnen und Entwicklern verbreitet, die bislang noch keinen eigenen Provider-Vertrag besitzen.

OpenCode, Claude Code und Cursor CLI: Lizenz, Preis und Philosophie

Bevor die Installation beginnt, lohnt sich ein Blick auf die Alternativen, denn die drei bekanntesten Terminal-Agenten unterscheiden sich fundamental in ihrem Geschäftsmodell. Anthropics Claude Code bleibt proprietär: Die LICENSE-Datei im offiziellen Repository enthält nur den Satz, dass alle Rechte bei Anthropic PBC liegen und die Nutzung den kommerziellen Geschäftsbedingungen unterliegt. Cursor CLI wiederum ist zwar kostenlos nutzbar, aber nur in einer stark limitierten Hobby-Stufe, für ernsthafte Nutzung verlangt der Anbieter mindestens 20 US-Dollar im Monat für den Pro-Tarif, 60 US-Dollar für Pro+ und 200 US-Dollar für Ultra.

OpenCode nimmt hier bewusst die Gegenposition ein. Der Quellcode steht unter der MIT-Lizenz offen im Repository, jeder darf ihn lesen, verändern und in eigene Projekte einbauen. Bezahlt wird ausschließlich für die Rechenleistung der angebundenen Modelle, nicht für den Agenten selbst. Wer bereits API-Zugänge bei OpenAI, Anthropic oder Google besitzt, nutzt diese einfach weiter und zahlt keinen zusätzlichen Aufpreis an OpenCode. Diese Offenheit hat allerdings eine Kehrseite: Während Cursor von Grund auf als Editor mit tiefer IDE-Integration gebaut wurde, bleibt der Schwerpunkt von OpenCode klar das Terminal, eine zusätzliche IDE-Anbindung existiert laut Dokumentation, tritt aber gegenüber der TUI klar in den Hintergrund.

Für Unternehmen mit strengen Compliance-Vorgaben zählt neben dem Preis vor allem die Nachvollziehbarkeit. Ein MIT-lizenzierter Agent lässt sich vor dem produktiven Einsatz vollständig durchlesen, in einer eigenen Umgebung bauen und bei Bedarf patchen, ohne auf einen Anbieter warten zu müssen. Bei proprietärer Software wie Claude Code bleibt dagegen nur der Weg über den Support des Herstellers, was für viele Teams akzeptabel ist, für Organisationen mit eigenen Audit-Anforderungen aber ein zusätzlicher Abwägungspunkt sein kann.

Merkmal	OpenCode	Claude Code	Cursor CLI
Lizenz	MIT (Open Source)	Proprietär, Anthropic-Geschäftsbedingungen	Proprietär
Einstiegspreis	Kostenlos, Nutzer zahlt nur die Modell-API	Über Claude-Abo bzw. API-Nutzung	Hobby-Tarif kostenlos, limitiert
Bezahltarif	Optional: OpenCode Go ab 10 $/Monat	Nach API-Verbrauch	Pro ab 20 $/Monat, Ultra 200 $/Monat
Modell-Wahl	Frei wählbar über Models.dev, u. a. Bedrock, Vertex AI	An Claude-Modelle gebunden	Mehrere Modelle, kuratiert
Primäre Oberfläche	Terminal (TUI), zusätzlich Web und Desktop	Terminal	Terminal und Editor-Integration

Voraussetzungen: Software, Accounts und Versionen

Die Einrichtung läuft auf macOS, Linux und Windows, wobei Windows-Nutzer entweder auf Scoop, Chocolatey oder eine WSL-Umgebung zurückgreifen. Ein Node.js-Unterbau ist praktisch, aber nicht zwingend, da das offizielle Installationsskript eigenständig funktioniert und keine Laufzeitumgebung voraussetzt. Wer stattdessen über npm, Bun oder pnpm installiert, braucht selbstverständlich die jeweilige aktuelle LTS-Version dieser Werkzeuge. Vor dem Start lohnt sich außerdem, mindestens einen API-Schlüssel für einen unterstützten Anbieter griffbereit zu haben, alternativ funktioniert auch der hauseigene Zugang über OpenCode Go oder OpenCode Zen ohne eigenen Provider-Vertrag.

Wer OpenCode ausschließlich in Containern betreiben möchte, etwa auf einem CI-Server ohne dauerhaften lokalen Zustand, kann direkt auf das offizielle Docker-Image zurückgreifen, statt eine eigene Binärdatei zu pflegen. Das eignet sich besonders für automatisierte Abläufe, bei denen der Agent nur für die Dauer eines einzelnen Jobs existieren soll.

Voraussetzung	Empfehlung	Zweck in dieser Anleitung
Betriebssystem	macOS, Linux oder Windows (Scoop/Chocolatey/WSL)	Trägt die OpenCode-Binärdatei
Terminal-Zugriff	Beliebiges Terminal mit Internetverbindung	Ausführung von Installation und TUI
curl	Aktuelle Version	Offizielles Installationsskript
Node.js, Bun oder pnpm	Aktuelle LTS-Version	Alternative Installation über Paketmanager
API-Schlüssel	Von einem Models.dev-Anbieter oder OpenCode Go/Zen	Verbindung zu einem Sprachmodell
Git-Repository	Ein lokales Projekt zum Testen	Praxisbeispiel in Schritt 5 bis 12

OpenCode in 12 Schritten einrichten

Die folgenden zwölf Schritte führen von der reinen Installation bis zu einem vollständig konfigurierten Agenten mit eigenen Werkzeugen, Team-Zugriff und Automatisierung. Wer parallel mitmacht, sollte für den gesamten Durchlauf etwa 45 Minuten einplanen.

Schritt 1: Installationsweg wählen und ausführen

Der schnellste Weg führt über das offizielle Shell-Skript, das automatisch die passende Binärdatei für das jeweilige Betriebssystem herunterlädt. Wer lieber über einen Paketmanager installiert, hat mit npm, Bun, Homebrew, pacman oder Scoop mehrere gleichwertige Alternativen.

# Offizielles Installationsskript (macOS/Linux)
curl -fsSL https://opencode.ai/install | bash

# Alternativ über npm
npm install -g opencode-ai

# macOS und Linux über Homebrew
brew install anomalyco/tap/opencode

# Windows über Scoop
scoop install opencode

# Arch Linux
sudo pacman -S opencode

Nach Abschluss der Installation bestätigt opencode --version die installierte Version. Erscheint hier nicht v1.18.32 oder neuer, hilft ein erneuter Lauf des Installationsskripts, da OpenCode sich selbst nicht automatisch aktualisiert. Wichtig für den Umstieg von älteren Anleitungen: Bis Mitte 2026 hieß das Projekt noch sst/opencode beziehungsweise kurzzeitig opencode-ai/opencode, seit der Umbenennung zu anomalyco/opencode zeigen ältere Installationsbefehle teils auf veraltete Paketnamen. Wer Fehler beim Auflösen eines Pakets bekommt, prüft zuerst, ob der verwendete Befehl noch den alten Namen referenziert.

Schritt 2: Erste Ausführung und Terminal-Oberfläche kennenlernen

Der Befehl opencode startet die TUI direkt im aktuellen Ordner. Beim ersten Start begrüßt die Oberfläche mit einer kurzen Übersicht der verfügbaren Slash-Befehle. Wichtig für den weiteren Ablauf sind vor allem /connect zur Provider-Anbindung und /init zur Projekt-Initialisierung, beide Befehle kommen in den nächsten Schritten zum Einsatz. Bereits an dieser Stelle lohnt sich ein Blick in den Projektordner selbst: OpenCode arbeitet grundsätzlich im aktuellen Verzeichnis und darunter, ein Start aus dem falschen Ordner führt schnell dazu, dass der Agent Dateien eines völlig anderen Projekts liest oder verändert.

cd mein-projekt
opencode
# In der TUI: Slash-Befehle mit / aufrufen, z. B. /connect

Schritt 3: Einen KI-Provider mit /connect verbinden

Der Befehl /connect öffnet eine Liste unterstützter Anbieter. Nach Auswahl eines Providers fragt OpenCode den passenden API-Schlüssel ab und speichert ihn lokal. Wer OpenCode Go oder OpenCode Zen nutzen möchte, wählt hier stattdessen den entsprechenden Eintrag, meldet sich über opencode.ai/auth an und kopiert von dort den generierten Schlüssel.

Alternativ funktioniert die Anbindung auch komplett ohne die TUI, direkt über die Kommandozeile:

# Provider-Login über die CLI statt über /connect
opencode auth login

# Gespeicherte Zugänge prüfen
opencode auth list

Die hinterlegten Zugangsdaten landen in der Datei ~/.local/share/opencode/auth.json. Diese Datei sollte niemals in ein Git-Repository gelangen, dazu später mehr im Abschnitt zu Sicherheit. Praktisch an diesem Ansatz: Ein einmal verbundener Provider bleibt über alle Projekte hinweg gespeichert, ein Wechsel des Arbeitsordners erfordert also keine erneute Anmeldung, solange derselbe Rechner genutzt wird.

Schritt 4: Provider-Optionen vergleichen und auswählen

Wer statt einer klassischen API lieber Googles Vertex AI einbindet, konfiguriert stattdessen drei Umgebungsvariablen und meldet sich über die Google-Cloud-CLI an, ganz ohne klassischen API-Schlüssel:

export GOOGLE_CLOUD_PROJECT="mein-projekt-id"
export VERTEX_LOCATION="europe-west3"
export GOOGLE_APPLICATION_CREDENTIALS="/pfad/zu/credentials.json"

gcloud auth application-default login

Für OpenAI-kompatible Anbieter, etwa lokale Server, die dieselbe API-Struktur nachbilden, nutzt OpenCode intern das Paket @ai-sdk/openai-compatible. Das öffnet die Tür für selbst gehostete Modelle, etwa über ein separat aufgesetztes LocalAI-Setup, solange der Endpunkt korrekt in options.baseURL eingetragen ist.

Schritt 5: Projekt initialisieren mit /init

In einem neuen oder bestehenden Projektordner erzeugt /init eine AGENTS.md-Datei, die OpenCode bei jeder künftigen Sitzung automatisch einliest. Dort gehören Projektkonventionen hin: bevorzugte Coding-Styles, Testbefehle, Ordnerstruktur. Je präziser diese Datei, desto seltener muss OpenCode während der eigentlichen Arbeit nachfragen.

# In der TUI eingeben:
/init

# Ergebnis: eine AGENTS.md im Projektordner
cat AGENTS.md

Schritt 6: Erste Aufgabe formulieren und Ausgabe prüfen

Eine einfache Testaufgabe zeigt, ob die Verbindung wirklich steht. Ein Prompt wie “Lies die package.json und liste alle Abhängigkeiten mit Version auf” reicht als erster Funktionstest, ohne dass dabei Code verändert wird. OpenCode zeigt in der TUI transparent an, welche Dateien es liest und welche Befehle es vorschlägt, bevor es sie tatsächlich ausführt.

Schritt 7: Die Konfigurationsdatei opencode.json anlegen

Für dauerhafte Einstellungen, etwa ein Standardmodell oder feste MCP-Server, legt eine Datei namens opencode.json im Projektordner den Rahmen fest. Diese Datei überschreibt globale Einstellungen für genau dieses Projekt und lässt sich problemlos ins Git-Repository einchecken, solange keine Schlüssel darin stehen.

{
  "model": "anthropic/claude-sonnet-4-6",
  "mcp": {},
  "plugin": []
}

Schritt 8: Einen MCP-Server einbinden

Über das Feld mcp in der Konfiguration lassen sich beliebig viele MCP-Server registrieren, jeder mit einem eindeutigen Namen, unter dem er in Prompts referenziert werden kann. Bei Remote-Servern mit Authentifizierung erkennt OpenCode automatisch eine 401-Antwort und startet den passenden OAuth-Ablauf, wer das lieber manuell anstößt, tut das über einen eigenen Befehl.

{
  "mcp": {
    "dateisystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    }
  }
}

# Authentifizierung bei einem MCP-Server manuell auslösen
opencode mcp auth dateisystem

Wer eigene MCP-Server bauen möchte, statt fertige zu verwenden, findet eine ausführliche Anleitung im Beitrag zum Aufbau eines eigenen MCP-Servers. OpenCode selbst übernimmt in diesem Schritt nur die Client-Seite gemäß der offiziellen MCP-Dokumentation, die eigentliche Serverlogik bleibt unabhängig vom Agenten.

Schritt 9: Eigene Agents und Subagents definieren

Neben dem Standard-Agenten unterstützt OpenCode benutzerdefinierte Agents, gespeichert entweder global unter ~/.config/opencode/agents/ oder projektspezifisch unter .opencode/agents/. Ein spezialisierter Agent für Code-Reviews etwa bekommt ein eigenes Systemprompt und eingeschränkte Werkzeuge, während ein zweiter Agent für Dokumentation ganz andere Vorgaben erhält. Das Prinzip ähnelt konzeptionell dem, was Claude Skills für Anthropics eigenes Ökosystem leisten, nur dass OpenCode dabei anbieterunabhängig bleibt und sich jeder Subagent gezielt auf ein anderes, günstigeres oder leistungsfähigeres Modell festlegen lässt.

Ein global gespeicherter Agent steht sofort in jedem neuen Projekt zur Verfügung, ein projektspezifischer Agent dagegen nur dort, wo er tatsächlich gebraucht wird, etwa weil ein Team eigene Konventionen für Datenbankmigrationen pflegt. Für den Einstieg reicht meist ein einziger zusätzlicher Agent, weitere lassen sich jederzeit ergänzen, sobald sich ein wiederkehrendes Muster in der täglichen Arbeit zeigt.

# Neuen Agenten interaktiv anlegen
opencode agent create

Schritt 10: Plugins laden und eigene Befehle bauen

Plugins erweitern OpenCode um zusätzliche Logik, etwa eigene Hooks vor und nach jedem Werkzeugaufruf. Plugin-Dateien gehören entweder in .opencode/plugins/ für ein einzelnes Projekt oder in ~/.config/opencode/plugins/ für alle Projekte. Alternativ lädt die plugin-Option in der Konfiguration ein fertiges npm-Paket direkt nach.

# Plugin per npm-Paketname aus der Konfiguration laden
opencode plugin mein-eigenes-plugin

Schritt 11: GitHub-Integration aktivieren

Für Repositories auf GitHub bringt OpenCode eine eigene Integration mit, die eine GitHub-Actions-Workflow-Datei anlegt und durch den restlichen Einrichtungsprozess führt. Damit lässt sich der Agent direkt aus Pull-Request-Kommentaren heraus ansprechen, ohne dass jemand lokal ein Terminal öffnen muss.

opencode github install

Schritt 12: Team-Zugriff über opencode web und attach einrichten

Der letzte Schritt öffnet OpenCode für den Zugriff über das Netzwerk. Ein Backend-Server lässt sich mit einer festen Portnummer starten, ein zweites Terminal, gegebenenfalls auf einer anderen Maschine, verbindet sich dann per attach mit genau diesem laufenden Prozess. Das eignet sich für Teams, die denselben Agenten-Zustand von mehreren Rechnern aus weiterführen wollen.

# Backend-Server starten
opencode web --port 4096 --hostname 0.0.0.0

# Von einem zweiten Terminal aus verbinden
opencode attach http://10.20.30.40:4096

Komplettes Beispielprojekt: Eine REST-API mit Tests bauen lassen

Um die Einrichtung an einem realistischen Fall zu prüfen, eignet sich eine kleine REST-API mit automatisierten Tests. Der Ordner bleibt bewusst leer, OpenCode soll die komplette Struktur selbst anlegen.

mkdir todo-api && cd todo-api
opencode
/init

Danach folgt ein einziger, aber konkret formulierter Auftrag direkt in der TUI:

Baue eine kleine REST-API in Node.js mit Express für eine Aufgabenliste
(Todo). Endpunkte: GET /todos, POST /todos, DELETE /todos/:id.
Speichere die Daten im Arbeitsspeicher. Schreibe zusätzlich Tests mit
Vitest, die alle drei Endpunkte abdecken, und richte ein npm-Skript
"test" dafür ein.

OpenCode legt daraufhin sichtbar Schritt für Schritt eine package.json, eine server.js und eine Testdatei an, führt npm install selbstständig aus und schlägt am Ende npm test vor, um das Ergebnis zu prüfen. Eine typische Ausgabe im Terminal sieht danach so aus:

✓ GET /todos gibt ein leeres Array zurück
✓ POST /todos legt eine neue Aufgabe an
✓ DELETE /todos/:id entfernt eine bestehende Aufgabe

Test Files  1 passed (1)
     Tests  3 passed (3)

Schlagen einzelne Tests fehl, lohnt sich ein zweiter, gezielter Prompt wie “Der Test für DELETE schlägt fehl, prüfe die Statuscode-Rückgabe”, statt die komplette Aufgabe neu zu formulieren. OpenCode behält den bisherigen Code-Kontext bei und passt nur den betroffenen Teil an.

Um den zuvor eingerichteten MCP-Server sinnvoll einzubinden, folgt als zweiter Auftrag eine Erweiterung, die auf externe Daten zugreift: “Lies über den MCP-Server ‘dateisystem’ die Datei README.md, falls sie existiert, und ergänze andernfalls eine neue README.md mit einer kurzen Beschreibung der API und allen drei Endpunkten.” An dieser Stelle zeigt sich der eigentliche Mehrwert von MCP: Der Agent nutzt das registrierte Werkzeug automatisch, ohne dass der Zugriffspfad im Prompt erneut ausbuchstabiert werden muss, und liefert am Ende eine vollständige, konsistente Dokumentation direkt neben dem Code.

Häufige Stolperfallen bei der OpenCode-Einrichtung

Die meisten Probleme bei der Einrichtung entstehen nicht durch Fehler im Werkzeug selbst, sondern durch Verwechslungen zwischen alten und neuen Projektnamen, unklare Provider-Zuordnungen oder übersehene Konfigurationsdetails. Die folgenden sieben Fallen tauchen in Foren und Support-Kanälen am häufigsten auf.

Veraltetes Repository referenziert: Ältere Anleitungen und Foreneinträge verweisen noch auf sst/opencode oder opencode-ai/opencode. Beide Namen führen inzwischen zu unterschiedlichen Projektständen, für aktuelle Installationen zählt ausschließlich anomalyco/opencode.
Provider-ID stimmt nicht mit der Konfiguration überein: Der in /connect gewählte Anbietername muss exakt der ID entsprechen, die in opencode.json hinterlegt ist. Eine kleine Abweichung im Namen führt zu einer stillen Fehlfunktion statt einer klaren Fehlermeldung.
API-Schlüssel versehentlich eingecheckt: Wer auth.json aus Versehen in ein Git-Repository kopiert, gibt seinen Provider-Zugang ungewollt frei. Die Datei gehört zwingend in die .gitignore.
Falsches Paket für OpenAI-kompatible Anbieter: Für Cerebras-Endpunkte braucht OpenCode das Paket @ai-sdk/cerebras, für die meisten anderen OpenAI-kompatiblen Anbieter dagegen @ai-sdk/openai-compatible. Wird das falsche Paket eingetragen, bricht die Verbindung ohne aussagekräftige Meldung ab.
Vertex-AI-Region falsch gesetzt: Wird VERTEX_LOCATION nicht gesetzt oder zeigt auf eine Region ohne das gewünschte Modell, quittiert Google Cloud die Anfrage mit einem Berechtigungsfehler, der auf den ersten Blick wie ein Authentifizierungsproblem wirkt.
MCP-Server ohne eindeutigen Namen: Zwei MCP-Einträge mit demselben Schlüssel in der Konfiguration überschreiben sich gegenseitig, nur der zuletzt definierte Server bleibt aktiv.
Installation über zwei Paketmanager gleichzeitig: Wer OpenCode zuerst über Homebrew und danach zusätzlich über npm installiert, landet mit zwei parallelen Binärdateien im PATH und wundert sich, warum ein Update nicht ankommt.

Troubleshooting: Die häufigsten Probleme und ihre Lösungen

Auch mit sorgfältiger Einrichtung tauchen im Alltag wiederkehrende Fehler auf. Die folgende Liste deckt die Fälle ab, die in der Praxis am häufigsten für Rückfragen sorgen, sortiert grob nach der Häufigkeit, mit der sie in der ersten Betriebswoche typischerweise auftreten.

“command not found: opencode” nach der Installation: Meist liegt die Binärdatei in einem Ordner, der nicht im PATH steht. Ein neu geöffnetes Terminal oder ein manuelles export PATH="$HOME/.opencode/bin:$PATH" löst das Problem in den meisten Fällen.
Provider-Verbindung schlägt trotz korrektem Schlüssel fehl: opencode auth list zeigt, ob der Schlüssel überhaupt gespeichert wurde. Fehlt der Eintrag, half häufig ein Abbruch mitten im /connect-Dialog, der Vorgang muss komplett wiederholt werden.
MCP-Server startet nicht: Ein Testlauf des zugrunde liegenden Befehls direkt im Terminal, ohne OpenCode, zeigt meist sofort, ob es an einem fehlenden Paket oder einem falschen Pfad liegt.
OAuth-Fenster öffnet sich nicht bei Remote-MCP-Servern: Auf Servern ohne grafische Oberfläche bleibt der automatische Browser-Aufruf wirkungslos. Der manuelle Befehl opencode mcp auth <servername> gibt stattdessen einen Link aus, der sich auf einem anderen Gerät öffnen lässt.
Vertex-AI-Zugriff wird verweigert: Häufigste Ursache ist ein abgelaufenes Token aus gcloud auth application-default login. Ein erneuter Login-Lauf erneuert die Anmeldedaten zuverlässig.
Plugin wird nicht geladen: Liegt die Plugin-Datei im falschen Ordner oder fehlt der Eintrag in der plugin-Option der Konfiguration, ignoriert OpenCode das Plugin stillschweigend, ohne Warnung in der TUI.
Sitzung über opencode attach bricht ab: Firewalls blockieren häufig eingehende Verbindungen auf dem gewählten Port. Ein kurzer Test mit curl http://server-ip:4096 von der Client-Seite aus zeigt schnell, ob überhaupt eine Netzwerkverbindung besteht.
Antworten wirken plötzlich langsamer als gewohnt: Ein Wechsel auf ein größeres oder stärker ausgelastetes Modell über OpenCode Zen erklärt oft einen spürbaren Geschwindigkeitsunterschied, ein Blick in die Zen-Preistabelle zeigt, welches Modell aktuell genutzt wird.
GitHub-Integration reagiert nicht auf Kommentare: Nach opencode github install braucht die neu angelegte Workflow-Datei einen eigenen Commit und Push, erst danach greift die Automatisierung in echten Pull Requests.

OpenCode Go und OpenCode Zen: Welches Preismodell passt?

Wer keinen eigenen Provider-Vertrag abschließen will, kann direkt auf die beiden hauseigenen Angebote von OpenCode zurückgreifen. OpenCode Go ist eine Abo-Lösung für 10 US-Dollar im Monat, jederzeit kündbar, mit verlässlichem Zugriff auf eine Auswahl offener Coding-Modelle. Für Qwen3.6 Plus etwa nennt die Dokumentation ein monatliches Limit von 60 US-Dollar an Modell-Nutzung, oberhalb dieses Limits greift eine zusätzliche Abrechnung.

OpenCode Zen funktioniert grundlegend anders: Statt eines Abos zahlt man dort klassisch nach Verbrauch, pro angefangener Million Tokens, mit eigenen Angaben zufolge ohne versteckte Aufschläge auf die reinen Modellkosten. Ein Einstiegsguthaben von 20 US-Dollar zuzüglich 1,23 US-Dollar Kartengebühr eröffnet den Zugang, danach richtet sich der Preis nach dem gewählten Modell.

Modell (über OpenCode Zen)	Preis Input je 1M Tokens	Preis Output je 1M Tokens
Claude Opus 5.5	4,00 $	20,00 $
Claude Sonnet 4.5 (bis 200K Kontext)	3,00 $	15,00 $
MiniMax M3	0,30 $	1,20 $
GLM 5.3 Flash	0,15 $	0,50 $
Big Pickle, MiMo-V2.6-Flash Free u. a.	kostenlos	kostenlos

Für den Einstieg spricht vieles für OpenCode Zen, da sich damit unterschiedliche Modelle ohne feste Monatskosten ausprobieren lassen. Wer dagegen regelmäßig mit denselben offenen Modellen arbeitet und planbare Kosten bevorzugt, fährt mit dem Abo von OpenCode Go häufig günstiger.

OpenCode und lange Kontextfenster: Was Kimi K3 & Co. praktisch verändern

Ein Grund, warum OpenCode gerade jetzt an Aufmerksamkeit gewinnt, liegt in der Kombination mit besonders langen Kontextfenstern. Kimi K3, veröffentlicht am 16. Juli 2026, gilt zum Zeitpunkt seiner Vorstellung als eines der größten frei verfügbaren offenen Modelle und bringt ein Kontextfenster von einer Million Tokens mit. Seit dem 18. September 2026 lässt es sich laut einem Bericht von Unite.AI zusätzlich über Amazon Bedrock beziehen, wodurch es über die native Bedrock-Anbindung von OpenCode direkt im Agenten nutzbar wird, ohne einen separaten Vertrag mit Moonshot AI abschließen zu müssen.

Für die tägliche Arbeit bedeutet das einen spürbaren Unterschied: Statt ein großes Repository in mehreren Anfragen häppchenweise zu analysieren, kann ein Agent mit einem Modell wie Kimi K3 deutlich größere Codeabschnitte, mehrere zusammenhängende Dateien oder sogar eine komplette Debugging-Sitzung in einem einzigen Kontext behalten. Das reduziert die Zahl der Rückfragen und verringert das Risiko, dass der Agent zwischen zwei Anfragen den Überblick über bereits getroffene Entscheidungen verliert.

Wichtig bei der Provider-Wahl: Ein größeres Kontextfenster kostet in der Regel auch mehr, gerade bei Abrechnung nach Tokens steigen die Kosten mit der Länge der übergebenen Historie. Für kleinere Projekte reicht meist ein günstigeres Modell mit kürzerem Kontext völlig aus, während sich der Aufpreis für ein Long-Context-Modell erst bei wirklich großen, monolithischen Codebasen oder bei mehrstündigen, zusammenhängenden Debugging-Sitzungen auszahlt. OpenCode erlaubt es, dieses Modell projektweise oder sogar nur für einen einzelnen Subagenten zu reservieren, statt es für jede einzelne Anfrage im gesamten Team einzusetzen.

Sicherheit und Datenschutz bei der Nutzung von OpenCode

Ein Agent, der eigenständig Dateien liest und Befehle ausführt, verdient einen bewussten Umgang mit Rechten. OpenCode zeigt zwar jede geplante Aktion vor der Ausführung an, verlässt sich dabei aber auf die Aufmerksamkeit der Nutzerin oder des Nutzers. Wer den Agenten in einem produktiven Repository laufen lässt, sollte destruktive Befehle wie rm -rf oder Force-Pushes generell nicht automatisch bestätigen, sondern einzeln prüfen.

Bei API-Schlüsseln gilt die übliche Regel: Getrennte Schlüssel für Entwicklungs- und Produktionsumgebungen, regelmäßige Rotation und ein Blick in die .gitignore, bevor der erste Commit erfolgt. Für Teams, die OpenCode über opencode web im Netzwerk freigeben, empfiehlt sich zusätzlich, den Port nicht direkt ins offene Internet zu stellen, sondern über ein VPN oder einen Reverse-Proxy mit eigener Authentifizierung abzusichern, da der Agent sonst mit vollem Dateisystemzugriff erreichbar wäre.

Ein weiterer Punkt betrifft MCP-Server von Drittanbietern. Da ein MCP-Server im Namen des Agenten Werkzeuge ausführt, sollte vor der Einbindung geprüft werden, wer den Server betreibt und welche Berechtigungen er tatsächlich anfordert. Ein Dateisystem-Server mit Schreibzugriff auf das gesamte Home-Verzeichnis birgt ein deutlich größeres Risiko als ein Server, der ausschließlich auf einen einzelnen Projektordner beschränkt ist. Wer unsicher ist, startet MCP-Server nach Möglichkeit in einem eigenen, eingeschränkten Benutzerkonto oder Container, statt sie mit vollen Nutzerrechten laufen zu lassen.

Fortgeschrittene Tipps für den produktiven Alltag

Wer OpenCode über den Testlauf hinaus im Alltag einsetzt, profitiert von ein paar zusätzlichen Kniffen. Eine feste AGENTS.md mit klaren Coding-Konventionen spart auf Dauer mehr Zeit als jede einzelne Prompt-Optimierung, da der Agent Regeln nur einmal lesen muss, statt sie in jeder Sitzung neu zu erklären.

Für komplexere Abläufe mit mehreren aufeinander folgenden Schritten lohnt sich der Blick auf spezialisierte Subagents, etwa einen strikt lesenden Agenten für Code-Reviews und einen zweiten mit Schreibrechten für die eigentliche Implementierung. Wer darüber hinaus mehrstufige Agenten-Workflows orchestrieren will, findet mit Frameworks wie LangGraph eine sinnvolle Ergänzung, die sich über MCP an denselben OpenCode-Agenten anbinden lässt, statt Logik doppelt zu pflegen.

Ein weiterer Tipp betrifft die Modellwahl je Aufgabe: Für einfache Refactorings reicht häufig ein günstiges Modell über OpenCode Zen, während komplexe Architekturentscheidungen von einem stärkeren, teureren Modell profitieren. Da sich das Modell projektweise in opencode.json festlegen lässt, empfiehlt sich für größere Codebasen ein zweites, günstigeres Profil für Routineaufgaben, das sich per Flag gezielt aktivieren lässt, statt dauerhaft das teuerste verfügbare Modell zu nutzen.

Schließlich zahlt sich ein Blick auf die MCP-Server-Auswahl aus: Ein einzelner, gut gepflegter Dateisystem- oder Datenbank-Server reicht für die meisten Projekte, mehrere überlappende Server erhöhen dagegen nur die Komplexität, ohne dass der Agent dadurch spürbar bessere Ergebnisse liefert.

Für Teams mit mehreren parallel laufenden Projekten lohnt sich außerdem, feste Namenskonventionen für Agents und MCP-Server über alle Repositories hinweg einzuführen. Heißt der Dateisystem-Server in einem Projekt “fs” und im nächsten “dateisystem”, verliert das Team schnell den Überblick, welche Konfiguration in welchem Ordner tatsächlich aktiv ist. Eine kurze interne Konvention, dokumentiert direkt in der jeweiligen AGENTS.md, verhindert dieses Durcheinander von Anfang an.

Ein letzter Kniff betrifft die Update-Disziplin: Da OpenCode sich nicht automatisch aktualisiert, verpassen Teams ohne festen Prozess leicht sicherheitsrelevante Fixes oder neue Provider-Integrationen. Ein einfacher wöchentlicher Check von opencode --version gegen die aktuelle GitHub-Release reicht in der Praxis meist aus, um nicht mehrere Versionssprünge hinter der aktiven Entwicklung zurückzufallen.

FAQ: Häufig gestellte Fragen zu OpenCode

Ist OpenCode wirklich komplett kostenlos?
Der Agent selbst ist unter MIT-Lizenz kostenlos und quelloffen. Kosten entstehen erst durch die Nutzung eines Sprachmodells, entweder über einen eigenen Provider-Vertrag oder über die hauseigenen Angebote OpenCode Go (10 $/Monat) und OpenCode Zen (nach Verbrauch).

Läuft OpenCode auch ohne Node.js?
Ja. Das offizielle Installationsskript über curl -fsSL https://opencode.ai/install | bash lädt eine eigenständige Binärdatei und benötigt keine separate Node.js-Umgebung. Nur wer über npm, Bun oder pnpm installieren möchte, braucht die entsprechende Laufzeitumgebung.

Kann OpenCode mit lokal gehosteten Modellen arbeiten?
Ja, über die OpenAI-kompatible Provider-Schnittstelle lassen sich auch selbst gehostete Endpunkte einbinden, solange die passende URL in options.baseURL eingetragen ist. Das eignet sich beispielsweise für ein eigenes LocalAI-Setup.

Was ist der Unterschied zwischen OpenCode Go und OpenCode Zen?
OpenCode Go ist ein festes Monatsabo für 10 US-Dollar mit Zugang zu einer Auswahl offener Modelle. OpenCode Zen berechnet dagegen nach tatsächlichem Verbrauch pro Million Tokens und deckt ein breiteres Modell-Spektrum ab, inklusive einiger kostenloser Modelle.

Unterstützt OpenCode das Model Context Protocol?
Ja, MCP-Server lassen sich direkt über das Feld mcp in der Konfigurationsdatei registrieren, inklusive automatischer OAuth-Behandlung für Remote-Server mit Authentifizierung.

Gibt es eine grafische Oberfläche für OpenCode?
Neben der primären Terminal-Oberfläche (TUI) existiert laut Projekt-Dokumentation zusätzlich ein Desktop-Modus sowie ein Web-Zugriff über einen lokal gestarteten Server, den mehrere Terminals per attach gemeinsam nutzen können.

Wie sicher sind die gespeicherten API-Schlüssel?
OpenCode speichert Zugangsdaten lokal in ~/.local/share/opencode/auth.json. Die Datei liegt unverschlüsselt auf der Festplatte, weshalb sie zwingend von Backups und Git-Repositories ausgeschlossen werden sollte.

Lohnt sich der Umstieg von Claude Code oder Cursor CLI?
Das hängt vom Anwendungsfall ab. Wer bereits zufrieden mit einer editorintegrierten Lösung wie Cursor arbeitet, gewinnt durch OpenCode vor allem Unabhängigkeit vom Anbieter und niedrigere Fixkosten, verzichtet dafür aber auf eine native IDE-Integration.

Funktioniert OpenCode auch für bestehende, große Codebasen?
Ja, grundsätzlich liest der Agent nur die Dateien, die für die jeweilige Aufgabe relevant sind, statt das komplette Projekt auf einmal zu laden. Bei sehr großen Repositories lohnt sich trotzdem eine präzise AGENTS.md, die dem Agenten die wichtigsten Einstiegspunkte und Ordnerkonventionen nennt, statt ihn jedes Mal neu suchen zu lassen.