Unbegrenztes OpenCode mit der Claude API

OpenCode ist ein terminalbasierter AI Coding Assistant, der über ein Provider-Plugin-System maximale Flexibilität bietet. Er unterstützt Custom Provider über npm packages, startet parallele Subagents für Recherche und Implementierung und hält kontinuierliche Terminal-Sessions offen, in denen der Kontext mit der Zeit wächst. Genau diese Architektur aus parallel arbeitenden Agents und langen Workflows macht OpenCode zu einem intensiven API-Verbraucher, der stark von einem unbegrenzten Flatrate-Zugang profitiert.

OpenCodes parallele Agent-Architektur

OpenCode arbeitet mit einem primären Agent, meist Build oder Plan, und kann zusätzlich Subagents wie explore oder scout starten, die parallel an verwandten Aufgaben arbeiten. Der Build Agent übernimmt direkte Codeänderungen, während der Plan Agent zuerst über Vorgehen, Risiken und Reihenfolge nachdenkt, bevor er Arbeitsschritte delegiert. Subagents führen eigene Conversations mit unabhängigem Kontext. Sie untersuchen Codebases, lesen Dokumentation, prüfen Hypothesen oder vergleichen Implementierungswege, während der Haupt-Agent weiterarbeitet. Für Entwickler fühlt sich das wie ein kleines Team im Terminal an: ein Agent schreibt, ein anderer recherchiert, ein dritter überprüft Annahmen. Diese Arbeitsweise ist extrem produktiv, erzeugt aber auch dauerhaft API-Traffic.

Dieses Parallelisieren bedeutet, dass mehrere Claude Conversations gleichzeitig über deinen API key laufen. Eine einzelne komplexe Aufgabe kann so aussehen: Der Build Agent editiert Dateien, während ein explore Subagent verwandten Code liest und ein scout Subagent externe Dokumentation oder Projektregeln prüft. Jeder Agent sammelt seinen eigenen Kontext unabhängig von den anderen. Drei Agents mit jeweils zehn Turns bedeuten nicht zehn, sondern dreißig API calls, und jeder Call trägt eine wachsende Conversation History mit. Bei klassischer Token-Abrechnung steigen die claude api kosten dadurch schnell, besonders wenn große Dateien, Terminal-Output und Tool-Ergebnisse im Kontext landen.

Zusätzlich unterstützt OpenCode Custom Agents, die du für projektspezifische Workflows definieren kannst. Jeder Custom Agent ist ein weiterer paralleler Verbraucher von API tokens. In Teams wird das schnell relevant: ein Research Agent für Architekturfragen, ein Review Agent für Security-Checks, ein Documentation Agent für README-Updates und ein Implementation Agent für Codeänderungen. Mit Per-Token-Billing schränken viele Nutzer Subagents bewusst ein, um Kosten zu kontrollieren. Mit einem unbegrenzter claude zugang über AI Prime Tech Unlimited kannst du OpenCode so arbeiten lassen, wie es gedacht ist: so viele Subagents starten, wie die Aufgabe sinnvoll verträgt, ohne bei jeder parallelen Untersuchung an die Rechnung zu denken.

Custom Provider in opencode.json konfigurieren

OpenCodes Provider-System nutzt npm packages für die API-Kommunikation. Für Claude über das Unlimited Gateway von AI Prime Tech Unlimited gibt es zwei sinnvolle Wege: @ai-sdk/anthropic für den nativen Anthropic-Pfad oder @ai-sdk/openai-compatible für den OpenAI-kompatiblen Pfad. Beide Varianten funktionieren, unterscheiden sich aber bei baseURL und API-Format. Konfiguriert wird das in deiner opencode.json, entweder im Projekt-Root oder global unter ~/.config/opencode/. Wenn du gerade einen claude api key erstellen möchtest, legst du den Key bei AI Prime Tech Unlimited an und trägst ihn anschließend in der Provider-Konfiguration ein oder referenzierst ihn über eine env var.

Für den OpenAI-kompatiblen Pfad fügst du einen Provider-Eintrag mit dem package @ai-sdk/openai-compatible hinzu, setzt baseURL auf https://claudeapikey.dev/v1 inklusive /v1 und konfigurierst deinen API key. Danach referenzierst du diesen Provider in deinen Model-Definitionen. Für den nativen Anthropic-Pfad verwendest du @ai-sdk/anthropic und setzt baseURL auf https://claudeapikey.dev, also den Root Host ohne /v1. Dieser Unterschied ist wichtig, weil ein falscher Suffix oft nicht als klarer HTTP-Fehler auftaucht, sondern als verwirrende Meldung wie model not available oder provider not found.

Die Struktur von opencode.json trennt Provider, also die Verbindung, von Models, also den tatsächlich genutzten Claude Modellen. Du definierst den Provider einmal und erstellst dann mehrere Model-Einträge, die auf denselben Provider zeigen, aber unterschiedliche model IDs verwenden. So kannst du Sonnet, Opus und Haiku sauber über dieselbe Gateway-Verbindung betreiben. Diese Trennung macht Setups wartbar: Wenn du später von einem Test-Key zu einem Produktiv-Key wechselst, musst du nur die Provider-Konfiguration ändern. Wenn du dagegen ein anderes Claude Modell ausprobieren willst, änderst du nur die Model-Zuordnung. Für Entwickler, die claude api kaufen oder eine Alternative zu per-token billing suchen, ist diese Klarheit besonders praktisch, weil sie OpenCode schnell in bestehende Projekte integrieren können.

Model-Konfiguration für Agents und Subagents

OpenCode erlaubt dir, verschiedene Modelle für unterschiedliche Rollen zuzuweisen. Das primary model übernimmt deine Hauptinteraktionen und die meisten komplexen Code-Aufgaben. Das small_model ist für triviale oder sehr schnelle Aufgaben gedacht, etwa Summaries, Formatierungen, kurze Lookups oder kleine interne Transformationen. Subagents können das primary model erben oder eigene Zuweisungen bekommen. Konfiguriert wird das alles im models-Abschnitt der opencode.json. Diese Flexibilität ist einer der Gründe, warum OpenCode bei größeren Repos gut skaliert: Nicht jeder Arbeitsschritt braucht das teuerste oder stärkste Modell, aber kritische Architekturentscheidungen profitieren von mehr Reasoning-Qualität.

Für das primary model auf einem Unlimited-Plan bietet sich claude-sonnet-4-5 als ausgewogene Wahl an: stark beim Coding, schnell genug für interaktive Sessions und robust bei längeren Kontexten. Wenn maximale Reasoning-Qualität wichtiger ist als Latenz, etwa bei Architektur-Reviews, schwierigen Refactorings oder tiefen Bug-Analysen, ist claude-opus-4-6 eine gute Wahl. Das small_model setzt du typischerweise auf claude-haiku-4-5, weil es schnelle, leichte Operationen erledigt, bei denen Geschwindigkeit wichtiger ist als Tiefe. In klassischer Abrechnung würdest du solche Entscheidungen oft nach Preis treffen; bei einer Flatrate kannst du stärker danach optimieren, welches Modell fachlich am besten zur Aufgabe passt.

Custom Agents in opencode.json können jeweils ihr eigenes Modell bekommen. Ein Research Agent kann Opus für tiefe Analysen nutzen, während ein Implementation Agent mit Sonnet schnell Code generiert und ein Summary Agent mit Haiku knappe Zwischenstände schreibt. Gerade bei Fragen wie claude code api kosten wird dieser Punkt relevant: Coding-Workflows erzeugen viele kleine und große Calls, nicht nur einzelne Chat-Anfragen. Mit unlimited kannst du Modelle nach Qualitätsanforderung statt nach Kostenangst auswählen. Das ist besonders nützlich, wenn du OpenCode über Stunden laufen lässt, mehrere Subagents nutzt und trotzdem nicht ständig prüfen willst, ob ein bestimmter Agent gerade zu viele Tokens verbraucht.

MCP-Integration und Tool-Erweiterung

OpenCode unterstützt MCP Server, also Model Context Protocol Server, die Agents mit zusätzlichen Tools ausstatten. MCP kann Datenbank-Clients, Dokumentationssuche, Deployment-Kommandos, Monitoring-Schnittstellen, Browser-Automation, interne APIs oder projektspezifische Werkzeuge bereitstellen. Die Server werden in opencode.json im mcp-Abschnitt konfiguriert, inklusive command, arguments und environment. Sobald sie angebunden sind, stehen die Tools den Agents zur Verfügung, ohne dass du OpenCode selbst ändern musst. Damit wird OpenCode nicht nur zu einem Chat im Terminal, sondern zu einer echten Entwicklungsumgebung, die Systeme lesen, ausführen und kombinieren kann.

Jedes MCP Tool fügt sein Schema zum System Prompt hinzu, der mit jeder Anfrage gesendet wird. Dadurch steigt der Basisverbrauch an Tokens, noch bevor die eigentliche Aufgabe beginnt. Wenn ein Agent ein MCP Tool aufruft, kommen Tool Call und Tool Result zusätzlich in den Conversation Context. Bei mehreren MCP Servern mit vielen Tools kann der Overhead erheblich sein: 5.000 bis 10.000 Tokens nur für Tool-Definitionen sind in umfangreichen Setups realistisch, bevor auch nur eine Datei gelesen oder ein Test ausgeführt wurde. Auf Per-Token-Billing wirkt das wie eine versteckte Grundgebühr pro Request, weshalb viele Teams ihre Tool-Sets künstlich klein halten.

Mit unlimited kannst du so viele MCP Server verbinden, wie im Workflow wirklich sinnvoll sind: Datenbanken für lokale Debugging-Sessions, Dokumentationsserver für Frameworks, Deployment Tools für Staging, Monitoring-Interfaces für Logs und Metriken oder interne Produkt-APIs. Der Token-Overhead reicher Tool-Sets ist durch die Flatrate abgedeckt. Dadurch kann OpenCode während einer Aufgabe auf alle Systeme zugreifen, die es braucht, statt zwischen Produktivität und API-Kosten abzuwägen. Eine claude api kostenlos im Sinne dauerhaft unbegrenzter professioneller Nutzung gibt es praktisch nicht; sinnvoller ist ein planbarer Zugang mit fester Rate, bei dem du OpenCode nicht wegen jedes zusätzlichen MCP Tools bremsen musst.

Kontinuierliche Terminal-Sessions und wachsender Kontext

OpenCode hält persistente Terminal-Sessions offen, in denen Agents Kommandos ausführen und Output beobachten. Anders als Tools, die Terminal-Kommandos einmal starten und danach vergessen, können OpenCode Agents lang laufende Prozesse beobachten, Streaming-Output lesen und in Echtzeit auf Änderungen reagieren. Jede Terminal-Interaktion landet im Conversation Context: command output, error messages, log lines, Build-Ausgaben und Testresultate werden Teil der wachsenden Historie. Genau das macht OpenCode so nützlich für echte Entwicklungsarbeit, denn der Agent sieht nicht nur statischen Code, sondern auch, wie sich das System beim Ausführen verhält.

Eine typische Development-Session besteht aus wiederholten build-test-fix cycles. Jeder Durchlauf fügt neuen Terminal-Output zum Kontext hinzu: Compiler-Fehler, Stack traces, Test-Failures, Linter-Warnungen, Server-Logs, Hot-reload-Meldungen und manchmal sehr lange Debug-Ausgaben. Über eine Stunde aktiver Arbeit kann allein der Terminal-Kontext auf Zehntausende Tokens anwachsen. Kombiniert mit Dateiinhalten, Chat-Verlauf, Tool-Schemas und Subagent-Konversationen nähern sich Sessions regelmäßig den Context Limits. Ohne Flatrate führt das dazu, dass Entwickler Output kürzen, Agents neu starten oder Kontext verlieren, obwohl gerade die Historie für gute Entscheidungen wichtig wäre.

Mit unlimited läuft dieser kontinuierliche Workflow ohne Token-Stress. Du kannst OpenCode deine Testsuite beobachten lassen, Build-Output analysieren, Server-Logs monitoren und nach jedem Fix erneut prüfen lassen. Jede Beobachtung kostet nichts extra und gibt dem Agent ein besseres Bild vom aktuellen Zustand deines Systems. Die Flatrate deckt stundenlange Terminal-Interaktion zum gleichen planbaren Preis ab, statt jede lange Log-Ausgabe in eine Kostenentscheidung zu verwandeln. Für Teams, die claude api kosten kalkulieren müssen, ist das besonders wertvoll: OpenCode wird nicht nur punktuell für einzelne Fragen genutzt, sondern als dauerhafter Pair-Programming-Prozess im Terminal.

Build Agent vs. Plan Agent Workflows

Der Build Agent implementiert Änderungen direkt. Er liest Dateien, schreibt Code, führt Kommandos aus und verifiziert Ergebnisse. Nutze ihn für klar definierte Aufgaben, bei denen du bereits weißt, was passieren soll: einen konkreten Bug fixen, eine Funktion mit eindeutigen Anforderungen ergänzen, ein bekanntes Pattern refactoren oder eine kleine API-Anpassung durchführen. Build ist handlungsorientiert und effizient, wenn die Aufgabe wenig Ambiguität enthält. In solchen Fällen wäre ein langer Planungsprozess eher Overhead, weil die Lösung offensichtlich ist und schnelle Ausführung zählt.

Der Plan Agent denkt zuerst über den Ansatz nach, bevor er handelt. Er analysiert Anforderungen, vergleicht Alternativen, identifiziert Risiken und erstellt einen strukturierten Plan, bevor Implementierungsschritte delegiert werden. Nutze ihn bei unklaren Aufgaben, Architekturentscheidungen, Multi-Step-Änderungen oder Refactorings, bei denen die richtige Reihenfolge nicht offensichtlich ist. Plan liefert bei komplexer Arbeit oft bessere Ergebnisse, verbraucht aber mehr API calls, weil zusätzlich zur Umsetzung eine Reasoning-Phase entsteht. In Per-Token-Modellen überspringen Nutzer diese Phase manchmal aus Kostengründen, obwohl sie fachlich sinnvoll wäre.

Mit unlimited kannst du für alles Nicht-Triviale standardmäßig den Plan Agent verwenden. Die zusätzlichen API calls für Planung, Abwägung und Delegation kosten nichts extra und führen bei komplexeren Aufgaben zuverlässig zu besseren Ergebnissen. Den Build Agent reservierst du für einfache, mechanische Änderungen, bei denen Planung keinen echten Nutzen bringt: Formatierungsfixes, simple Renames, offensichtliche Bugfixes oder kleine Anpassungen an bereits verstandenen Stellen. So nutzt du OpenCode so, wie erfahrene Entwickler arbeiten: erst denken, wenn die Aufgabe komplex ist; direkt handeln, wenn sie eindeutig ist. Die Frage ist dann nicht mehr, ob Plan zu teuer ist, sondern welcher Workflow die beste Qualität liefert.

Troubleshooting der OpenCode Provider-Konfiguration

Wenn OpenCode deinen Provider nicht lädt, prüfe zuerst, ob das npm package installiert ist. Führe im Projektverzeichnis npm install @ai-sdk/openai-compatible oder npm install @ai-sdk/anthropic aus, je nachdem welchen Pfad du nutzt. OpenCode löst Provider Packages aus den node_modules deines Projekts auf. Ist das Package nicht installiert, wird die Provider-Konfiguration möglicherweise stillschweigend ignoriert oder nur indirekt als fehlendes Modell sichtbar. Gerade nach dem Kopieren einer opencode.json in ein neues Repo ist das ein häufiger Fehler: Die Konfiguration sieht korrekt aus, aber die Runtime kann das Provider Package nicht finden.

Bei Connection Errors solltest du prüfen, ob das baseURL-Format zum Provider Package passt. @ai-sdk/openai-compatible erwartet eine URL mit /v1-Suffix, also https://claudeapikey.dev/v1. @ai-sdk/anthropic erwartet den Root Host ohne /v1, also https://claudeapikey.dev. Wenn du diese Varianten mischst, entstehen oft 404-Fehler oder Meldungen, die eher nach Modellproblem als nach URL-Problem klingen. Prüfe außerdem, ob dein API key korrekt gesetzt ist, ob eine env var wirklich geladen wird und ob keine zusätzlichen Leerzeichen oder Anführungszeichen im Wert gelandet sind.

Wenn Subagents fehlschlagen, während der primary agent funktioniert, ist meist die Model-Konfiguration unvollständig. Subagents können andere Model-Zuweisungen nutzen als der Haupt-Agent. Wenn ein Subagent auf ein Modell verweist, das auf dem Gateway nicht existiert oder falsch geschrieben ist, kann er still scheitern oder nur eine generische Fehlermeldung liefern. Stelle sicher, dass alle Model-Einträge in opencode.json gültige model IDs verwenden, die AI Prime Tech Unlimited unterstützt. Prüfe außerdem, ob small_model, custom agent models und default model konsistent gesetzt sind. Wer gerade erst eine Claude API kaufen oder ein Gateway einrichten will, sollte mit einer minimalen Konfiguration starten, einen einfachen Prompt testen und danach Subagents, MCP und Custom Agents schrittweise ergänzen.

// opencode.json - OpenAI-kompatibler Pfad
{
  "providers": {
    "unlimited": {
      "package": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "https://claudeapikey.dev/v1",
        "apiKey": "<your AI Prime Tech Unlimited key>"
      }
    }
  },
  "models": {
    "sonnet": { "provider": "unlimited", "model": "claude-sonnet-4-5" },
    "opus":   { "provider": "unlimited", "model": "claude-opus-4-6" },
    "haiku":  { "provider": "unlimited", "model": "claude-haiku-4-5" }
  },
  "agent": { "model": "sonnet", "small_model": "haiku" }
}

FAQ

Welches npm package sollte ich für Claude in OpenCode verwenden?
Nutze @ai-sdk/openai-compatible mit baseURL https://claudeapikey.dev/v1 oder @ai-sdk/anthropic mit baseURL https://claudeapikey.dev ohne /v1. Beide Wege funktionieren; der OpenAI-kompatible Pfad ist in OpenCode-Konfigurationen meist verbreiteter.

Wie beeinflussen Subagents die API-Nutzung in OpenCode?
Jeder Subagent, etwa explore, scout oder ein Custom Agent, führt eine eigene unabhängige Conversation mit wachsendem Kontext. Drei parallele Subagents mit jeweils zehn Turns bedeuten dreißig separate API calls. Mit unlimited ist diese Parallelität vollständig über die Flatrate abgedeckt.

Was ist small_model und wann wird es genutzt?
small_model übernimmt einfache Aufgaben wie Summaries, Output-Formatierung und schnelle Lookups, bei denen Geschwindigkeit wichtiger ist als Tiefe. Setze es für leichte Operationen auf claude-haiku-4-5, um besonders schnelle Antwortzeiten zu bekommen.

Kann ich in OpenCode eigene Custom Agents definieren?
Ja. Du kannst in opencode.json Agent-Definitionen mit eigenen System Prompts, Tool-Zugriffen und Model-Zuweisungen anlegen. Mit unlimited erstellst du so viele spezialisierte Agents, wie dein Workflow braucht, etwa für Research, Implementierung, Review oder Dokumentation, ohne Kosten pro Agent einplanen zu müssen.

Warum wächst der Kontext in OpenCode während Terminal-Sessions so stark?
OpenCode hält persistente Terminal-Sessions offen, in denen sämtlicher command output wie Build Logs, Testresultate und Fehlermeldungen im Conversation Context gesammelt wird. Eine Stunde aktive Entwicklung kann allein durch Terminal-Output Zehntausende Tokens hinzufügen. Mit unlimited kostet dieses Wachstum nichts extra.