DeepSeek Harness vs OpenCode: Die Token-Nutzungslücke, die die meisten Entwickler übersehen

Du hast ein günstiges Modell gewählt. Du hast die Rechnung auf der Modellkarte durchgerechnet. Und dann kam die Abrechnung – und sie sah ganz anders aus als deine Rechnung.

Diese Lücke liegt fast nie am Modell. Sie liegt am Harness. Der Harness bestimmt, wie oft dein Modell aufgerufen wird, wie viel von der Konversation bei jedem einzelnen Aufruf erneut gesendet wird, wie groß die Tool-Schemas sind und ob ein fehlgeschlagener Testlauf drei oder zwölf Mal wiederholt wird. Gleiches Modell, gleiche Aufgabe, zwei Harnesses – völlig unterschiedliche Token-Zahlen.

Am 13. August 2026 hat DeepSeek seinen eigenen Agent-Harness als Open Source veröffentlicht, und die Debatte wurde schnell laut. Auf der einen Seite steht ein zwei Wochen altes Repository aus dem Labor, das das Modell baut. Auf der anderen Seite steht OpenCode, der Coding-Agent mit den meisten Sternen auf GitHub. Beide sind MIT-lizenziert. Beide laufen mit jedem Modell, das du ihnen zuweist.

Das hier ist also die ehrliche Version des Vergleichs. Keine Stimmungen, keine Sterne. Was jeder der beiden tatsächlich mit deinem Token-Verbrauch macht – und wie du es in etwa fünfzehn Minuten in deinem eigenen Repository misst.

Die wichtigsten Erkenntnisse

• DeepSeek Harness ist eine Plugin-first-Agent-Laufzeitumgebung von DeepSeek AI, MIT-lizenziert, in TypeScript geschrieben, noch als Developer Preview gekennzeichnet. Modelle, Tools, Sessions, Speicher, Sandboxes, Loops und sogar die Agent-Loop selbst sind austauschbare Plugins.
• OpenCode ist ein in Go geschriebener, terminalbasierter Coding-Agent mit rund 198.000 GitHub-Sternen, einem ausgereiften TUI, LSP-Support und einem großen Provider-Katalog. Er ist heute der sichere Standard.
• Die Wahl des Harnesses bewegt den Token-Verbrauch stärker als die meisten erwarten. In einem Benchmark mit 30 Workflows auf DeepSeek V4 Flash lagen die getesteten Harnesses zwischen etwa 192.000 und 1.400.000 durchschnittlichen Token pro Aufgabe.
• DeepSeek Harness war nicht in diesem Benchmark. Er wurde zwei Tage nach der Veröffentlichung des Benchmarks gelauncht. Wer also gerade Zahlen zum Harness-Benchmark zitiert, rät.
• Beide sind modellagnostisch, du kannst also beide auf denselben OpenAI-kompatiblen Endpunkt richten und einen echten Vergleich unter gleichen Bedingungen durchführen. Das ist die einzige Zahl, die für deine Codebase zählt.

Zwei Laptops nebeneinander auf einem sonnigen Schreibtisch, die dieselbe Coding-Aufgabe über zwei verschiedene Agent-Harnesses ausführen

Der einzig faire Weg, DeepSeek Harness vs. OpenCode zu testen: ein Modell, eine Aufgabe, zwei Terminals.

Warum DeepSeek Harness vs. OpenCode zum Argument des Monats wurde

DeepSeek formuliert es als Slogan: Agent = Modell + Harness. Das Modell denkt, der Harness liest Dateien, führt das Terminal aus und ruft Tools auf. Zwei Jahre lang hat jeder die erste Hälfte optimiert und die zweite Hälfte als Klempnerarbeit behandelt.

Die Klempnerarbeit erwies sich als teuer.

Composio hat 30 komplexe Multi-App-Workflows durch 8 verschiedene Agent-Harnesses laufen lassen, alle mit demselben DeepSeek V4 Flash Modell, mit einem 900-Sekunden-Limit pro Aufgabe und binärer programmatischer Bewertung über 240 Läufe (Composio, August 2026). Überall dasselbe Modell. Die Ergebnisse waren nicht annähernd gleich.

Lies die Token-Spalte noch einmal. Der sparsamste Harness verbrauchte etwa ein Siebtel der Tokens des verschwenderischsten – mit identischem Modell und identischen Aufgaben. Die Schlussfolgerung des Benchmarks selbst: Harnesses „können genauso viel ausmachen wie die Modelle, die sie ausführen".

Jetzt kommt der Teil, den die meisten Artikel überspringen. DeepSeek Harness steht nicht in dieser Tabelle. Der Benchmark wurde am 11. August veröffentlicht, der Harness kam am 13. August. Es gibt noch keine belastbare Kopf-an-Kopf-Token-Zahl für DeepSeek Harness – und wer dir diesen Monat eine zeigt, hat sie entweder selbst auf einer engen Aufgabe laufen lassen oder sie erfunden. Was dir die Tabelle liefert, ist eine solide, belegte Baseline für OpenCode: 692.000 Token pro Aufgabe, 46,7 % Erfolgsquote, 129,7 Sekunden Median.

Das ist die Zahl, die du schlagen willst – und der Rest dieses Artikels zeigt, wie du es ehrlich testest.

DeepSeek Harness vs. OpenCode: gleiches Modell, ein Endpunkt, zwei Laufzeitumgebungen

Hier die praktische Form beider Tools, bevor wir etwas ausführen.

Die wichtigste Zeile ist die Architektur-Zeile. OpenCode gibt dir einen gut gebauten Agenten und lässt dich die Ränder erweitern. DeepSeek Harness gibt dir ein Skelett und lässt dich das Rückgrat ersetzen – einschließlich der Agent-Loop, die selbst ein Plugin ist. Das ist wirklich ungewöhnlich – und genau deshalb ist es noch eine Preview.

Beide sind modellagnostisch, und genau das macht einen fairen Test möglich. Richte beide auf einen einzigen OpenAI-kompatiblen Endpunkt mit einem Modell aus, und jeder Unterschied, den du misst, gehört zum Harness.

Für diesen Walkthrough nutze ich DeepSeek V4 Flash von Atlas Cloud, weil es einen einfachen OpenAI-kompatiblen Endpunkt bereitstellt, den beide Harnesses ohne Adaptercode akzeptieren – und derselbe Schlüssel für beide Läufe funktioniert. Die deepseek-v4-flash-0731-Listung dort kostet $0,14 pro Million Input-Token und $0,28 pro Million Output-Token, mit einem Kontextfenster von 1.048.576 Token und 393.216 maximalem Output, Stand August 2026. Jeder OpenAI-kompatible Anbieter funktioniert für diesen Test. Wichtig ist, dass beide Harnesses denselben Endpunkt treffen.

Wissenswert, bevor du ein Modell wählst: OpenCode veröffentlicht eigene aggregierte Nutzungsdaten, und DeepSeek-Modelle haben 233 Billionen Token durchgeschleust, wobei V4 Flash 85,5 % davon ausmacht und V4 Pro die restlichen 14,5 % (OpenCode, August 2026). Flash ist das, womit das Ökosystem tatsächlich arbeitet.

Schritt 1: DeepSeek Harness vs. OpenCode auf dasselbe Modell richten

Hol dir einen API-Schlüssel und eine Base-URL und füttere beide Tools mit genau demselben Paar. Erstelle den Schlüssel in der Atlas-Cloud-Konsole und exportiere ihn einmalig:

bashCopy
1export ATLAS_API_KEY="your-api-key"
2

Bevor du einen der Harnesses verdrahtest, prüfe den Endpunkt und die exakte Modell-ID mit einem einzigen Aufruf. Wenn das keinen Text zurückgibt, wird nichts Weiteres funktionieren:

bashCopy
1curl https://api.atlascloud.ai/v1/chat/completions \
2  -H "Authorization: Bearer $ATLAS_API_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "model": "deepseek-ai/deepseek-v4-flash-0731",
6    "messages": [{"role": "user", "content": "Reply with the single word: ready"}]
7  }'
8

Es hilft zu sehen, wie das Modell die echte Aufgabe einmal direkt über den Endpunkt beantwortet, bevor du es einem Agenten übergibst. Dann weißt du: Ein fehlgeschlagener Lauf liegt am Harness und nicht an der Route:

Die Aufgaben-Prompt des Artikels an api.atlascloud.ai, neben der echten Antwort, die DeepSeek V4 Flash 0731 zurückgab, und dem vom Aufruf gemeldeten Token-Verbrauch

Ein echter Aufruf an deepseek-ai/deepseek-v4-flash-0731, dieselbe Modell-ID, die beide Harnesses verwenden: 148 Prompt-Token hinein, 6.879 Output-Token zurück, davon 5.731 Reasoning. Das ist dein Ausgangswert, bevor ein Harness ein einziges Tool-Schema hinzufügt.

Jetzt konfiguriere jede Seite. DeepSeek Harness liest $DSH_HOME/settings.yaml, und benutzerdefinierte OpenAI-kompatible Provider werden unter dem llm-pi-ai-Plugin eingetragen (DeepSeek Harness Docs, August 2026):

yamlCopy
1llm-pi-ai:
2  providers:
3    atlas:
4      apiKeyEnv: ATLAS_API_KEY
5      api: openai-completions
6      baseURL: https://api.atlascloud.ai/v1
7      models:
8        - id: deepseek-ai/deepseek-v4-flash-0731
9

Das api-Feld akzeptiert openai-completions, openai-responses oder anthropic-messages. Verwende hier openai-completions. Wenn du das YAML nicht von Hand bearbeiten möchtest: Das Web-UI bietet unter Settings → Models → Add a custom provider denselben Block und speichert den Schlüssel stattdessen in $DSH_HOME/.credentials.yaml.

OpenCode liest opencode.json im Projektstamm oder im globalen Konfigurationsverzeichnis (OpenCode Docs, August 2026):

jsonCopy
1{
2  "$schema": "https://opencode.ai/config.json",
3  "provider": {
4    "atlas": {
5      "npm": "@ai-sdk/openai-compatible",
6      "name": "Atlas Cloud",
7      "options": {
8        "baseURL": "https://api.atlascloud.ai/v1",
9        "apiKey": "{env:ATLAS_API_KEY}"
10      },
11      "models": {
12        "deepseek-ai/deepseek-v4-flash-0731": {
13          "name": "DeepSeek V4 Flash 0731",
14          "limit": { "context": 1048576, "output": 393216 }
15        }
16      }
17    }
18  },
19  "model": "atlas/deepseek-ai/deepseek-v4-flash-0731"
20}
21

Verwende @ai-sdk/openai-compatible, nicht @ai-sdk/openai, da dieser Endpunkt /v1/chat/completions bedient. Setze die limit-Werte auf die echten Kontext- und Output-Zahlen, denn OpenCode nutzt sie, um zu entscheiden, wann zusammengefasst wird – und ein falsches Limit verfälscht deinen Token-Vergleich erheblich.

Schritt 2: Die Benchmark-Aufgabe in DeepSeek Harness ausführen

Wähle eine Aufgabe, die groß genug ist, um mehrere Tool-Aufrufe zu erfordern, und klein genug, um objektiv zu bewerten. Mehrere Dateien, plus eine Testsuite, die wirklich bestehen muss. Verwende für beide Läufe denselben Repo-Stand – committe oder stashe also vorher.

Das ist der exakte Aufgaben-Prompt. Füge ihn wortwörtlich in beide Harnesses ein:

textCopy
1In this repository, add a token-bucket rate limiter middleware for the Express
2app in src/server.js. Limit each IP to 60 requests per minute. On rejection,
3return HTTP 429 with the JSON body {"error":"rate_limited","retryAfter":<seconds>}.
4Wire the middleware into every /api/* route. Add unit tests in
5test/rate-limit.test.js covering three cases: a request under the limit is
6allowed, a request over the limit is blocked with 429, and the counter resets
7after the window expires. Run the test suite and fix failures until it passes.
8Do not modify any file outside src/ and test/.
9

Starte Harness aus deinem Projektverzeichnis:

bashCopy
1cd /path/to/your/repo
2npx @deepseek-ai/dsh web
3

Das startet das Web-UI unter http://127.0.0.1:3080. Wähle den atlas-Provider und das Modell deepseek-ai/deepseek-v4-flash-0731, füge die Aufgabe ein und lass es bis zum Ende laufen. Greife nicht ein, beantworte keine Rückfragen mit Hinweisen. Jede Hilfe, die du dem einen Harness gibst und dem anderen nicht, macht den Vergleich ungültig.

Wenn es fertig ist, öffne die Trajectory-Ansicht. Das ist das Session-Protokoll – und dort leben die Token-Zahlen.

Schritt 3: Den Lauf in OpenCode wiederholen für einen fairen DeepSeek-Harness-vs-OpenCode-Test

Setze das Repo auf exakt denselben Ausgangszustand zurück. Dieser Schritt ist es, bei dem die meisten informellen Vergleiche leise scheitern, weil der zweite Harness auf einem Repo startet, das der erste bereits halb repariert hat.

bashCopy
1git checkout -- . && git clean -fd
2

Dann führe OpenCode gegen dasselbe Modell aus:

bashCopy
1opencode --model atlas/deepseek-ai/deepseek-v4-flash-0731
2

Füge den identischen Aufgaben-Prompt aus Schritt 2 ein. Verwende den Standard-build-Agenten, denn der hat vollen Datei- und Shell-Zugriff. Wieder keine Hinweise, keine Kurskorrekturen, dieselbe Hands-off-Behandlung.

Lass es fertig laufen und verifiziere dann beide Läufe so, wie du jeden PR bewerten würdest:

bashCopy
1npm test
2

Ein Lauf, der die Suite rot hinterlässt, ist nicht bestanden – egal wie selbstbewusst die Zusammenfassung klang. Bewerte binär, genau nach der Composio-Methodik. Ein halb funktionierender Rate-Limiter ist ein Fehlschlag.

Schritt 4: DeepSeek Harness vs. OpenCode Token-Verbrauch lesen

Jetzt sammle die Zahlen. Beide Harnesses verfolgen die Nutzung, aber sie präsentieren sie sehr unterschiedlich – und das ist der größte Unterschied im Alltag zwischen den beiden.

DeepSeek Harness bringt standardmäßig einen Token-Zähler mit. Er bietet drei Session-Projektionen, die du direkt lesen kannst: tokenUsage für den laufenden Gesamtwert, contextPressure dafür, wie nah du am Fenster bist, und contextBreakdown dafür, wohin die Tokens tatsächlich gegangen sind. Letzteres ist das Nützlichste, denn es zeigt dir, ob deine Rechnung aus System-Prompt, Tool-Schemas, Datei-Reads oder Konversations-Replay besteht. Der Zähler verwendet eine feste Heuristik von etwa einem Token pro vier Zeichen statt eines echten Tokenizers – behandle ihn also als starke Schätzung, nicht als Rechnung.

Harness behandelt auch einen vollen Kontext anders. Statt abzuschneiden, faltet die Kompaktierungs-Engine: Sie ersetzt die modellsichtbare Oberfläche durch eine Zusammenfassung, während das vollständige Protokoll in der Persistenzschicht bleibt. Du verlierst Tokens aus dem Prompt, aber keine Historie aus dem Protokoll.

OpenCode verfolgt Tokens und Kosten pro Session und zeigt sie während der Arbeit in der Statuszeile an. Das TUI-interne Breakdown ist bewusst minimal – deshalb gibt es ein kleines Ökosystem externer Analysetools, die direkt die OpenCode-Session-Datenbank lesen, um die Nutzung nach Tool und Cache-Hit-Rate aufzuschlüsseln. Wenn du eine Zuordnung pro Tool willst, musst du etwas installieren.

Für den Vergleich selbst solltest du keinem der beiden internen Zähler als letztes Wort vertrauen. Nutze die Provider-Zahl, denn das ist es, was du tatsächlich zahlst:

Die sauberste Methode: Erstelle zwei separate API-Schlüssel, einen namens harness-test und einen namens opencode-test, und verwende jeweils genau einen pro Lauf. Dann liefert die eigene Nutzungsseite des Providers einen unbestreitbaren Side-by-Side-Vergleich ohne Schätzfehler. Dieser Trick dauert zwei Minuten und beseitigt jede Meinungsverschiedenheit darüber, wessen Zähler richtig ist.

DeepSeek-Harness-Token-Verbrauch: Was die Rechnung wirklich bewegt

Sobald du echte Zahlen hast, sind das die Stellschrauben, die sich lohnen. Sie gelten für beide Harnesses und sie sind viel wichtiger als die Frage, welchen du gewählt hast.

Konversations-Replay ist meist der größte Posten. Agents senden die wachsende Konversation bei jedem Schritt erneut. Eine Aufgabe mit 40 Schritten kostet nicht 40 Prompts, sondern eher die Summe von 40 zunehmend längeren Prompts. Genau deshalb lag die Benchmark-Spanne bei identischer Arbeit zwischen 192.000 und 1.400.000 Token. Harnesses, die aggressiv zusammenfassen, landen am unteren Ende dieser Spanne.

Cache-Hits sind die günstigste Optimierung, die es gibt. DeepSeek V4 Flash Cache-Hits kosten etwa $0,0028 pro Million Token gegenüber $0,14 pro Million bei einem Miss – ungefähr 98 % günstiger. Caching funktioniert nur, wenn das Request-Präfix byteweise identisch ist – genau deshalb erzwingt DeepSeek Harness strikte {{variable}}-Interpolation mit Fail-loud-Semantik und hält einen stabilen Request-Header. Ein Harness, der deinen System-Prompt zwischen den Aufrufen durcheinanderbringt, verwandelt leise jeden Hit in einen Miss.

Tool-Schemas reisen bei jedem einzelnen Aufruf mit. Zwanzig verbundene MCP-Server bedeuten zwanzig Schema-Sätze im Prompt – für immer, ob die Aufgabe sie braucht oder nicht. Trenne vor dem Benchmark, was diese Aufgabe nicht braucht, sonst misst du deine MCP-Konfiguration statt deines Harnesses.

Übergroße Tool-Ergebnisse vergiften den Kontext. Ein einzelnes cat einer 3.000-Zeilen-Datei oder ein ausführlicher Test-Runner, der komplette Stacktraces ausgibt, bleibt für den Rest des Laufs in der Konversation. Harness hat einen optionalen Ergebnis-Pruning-Begleiter, der übergroße Tool-Ergebnisse vor der Zusammenfassung umschreibt. Es lohnt sich, ihn zu aktivieren.

Retries sind unsichtbar, bis du Aufrufe zählst. Ein Harness, der einen fehlgeschlagenen Test dreimal wiederholt, gibt dreimal aus. Vergleiche die Spalte mit der Anzahl der Aufrufe, nicht nur die Gesamt-Token, sonst diagnostizierst du eine Retry-Schleife fälschlich als teures Modell.

Bei den Kosten ist die Rechnung einfach, sobald du eine Token-Zahl hast. Zum Atlas-Cloud-Tarif für DeepSeek V4 Flash liegt eine Aufgabe mit 692.000 Token, gewichtet Richtung Input, im niedrigen einstelligen Cent-Bereich. Das ist die gute Nachricht dieser ganzen Kategorie: Das Modell ist billig genug, dass Harness-Verschwendung eher ein Effizienzproblem als ein Budgetnotfall ist. Es wird erst zu einer echten Zahl, wenn du es mit einem Team multiplizierst, das den ganzen Tag, jeden Tag läuft. Stöbere durch den vollständigen Modellkatalog, wenn du denselben Test mit einem zweiten Modell fahren und Modelleffekte von Harness-Effekten trennen willst.

Eine Einschränkung, die deine Entscheidung mehr prägen sollte als jede Token-Zahl: DeepSeek Harness ist ausdrücklich in der Developer Preview, und seine eigene README warnt in Großbuchstaben vor Kompatibilitäts-Breaking-Changes. Das ist gut zum Benchmarkt – und riskant, um ein Team diesen Monat darauf zu standardisieren. OpenCode ist die langweilige Wahl – und langweilig ist ein Feature, wenn es gegen dein Produktions-Repo läuft.

Häufig gestellte Fragen

Ist DeepSeek Harness besser als OpenCode?

Noch nicht – für die meisten Menschen. OpenCode ist ausgereift, terminalbasiert, hat rund 198.000 Sterne und einen großen Provider-Katalog – und es funktioniert heute. DeepSeek Harness ist zwei Wochen alt, in der Developer Preview und warnt vor Breaking Changes. Harness ist architektonisch interessanter, weil jede Komponente – einschließlich der Agent-Loop – ein austauschbares Plugin ist. Wenn du Agent-Interna neu schreiben willst, ist Harness dafür gebaut. Wenn du diese Woche Code ausliefern willst, OpenCode.

Funktioniert DeepSeek Harness nur mit DeepSeek-Modellen?

Nein. Es ist modellagnostisch. Es bringt Katalog-Provider für DeepSeek, Anthropic, OpenAI, Bedrock, Vertex, Azure und Codex mit, und du kannst jeden benutzerdefinierten Provider hinzufügen, der openai-completions, openai-responses oder anthropic-messages spricht, indem du einen Block zu $DSH_HOME/settings.yaml hinzufügst. Die Konfiguration in Schritt 1 richtet es ohne Adaptercode auf einen Drittanbieter-Endpunkt mit OpenAI-Kompatibilität aus.

Wie prüfe ich den DeepSeek-Harness-Token-Verbrauch?

Über den integrierten Token-Zähler, der standardmäßig eingebunden ist und die Projektionen tokenUsage, contextPressure und contextBreakdown bereitstellt, sichtbar in der Trajectory-Ansicht. Beachte, dass er mit einer festen Heuristik von etwa einem Token pro vier Zeichen schätzt, statt einen echten Tokenizer auszuführen. Für Abrechnungsgenauigkeit lies stattdessen das Nutzungs-Dashboard deines Providers – idealerweise mit einem dedizierten API-Schlüssel pro Lauf. Community-Plugins wie Token-Usage-Dashboards ergänzen darüber hinaus persistente Aufzeichnungen pro Session.

Welcher Harness verbraucht weniger Tokens: DeepSeek Harness oder OpenCode?

Es gibt noch keinen veröffentlichten Kopf-an-Kopf-Vergleich. Der 8-Harness-Benchmark auf DeepSeek V4 Flash hat OpenCode mit durchschnittlich 692.000 Token pro Aufgabe gemessen – aber er lief zwei Tage vor der Veröffentlichung von DeepSeek Harness, also war Harness nicht enthalten. Wer eine Harness-Zahl aus diesem Benchmark zitiert, zitiert etwas, das es nicht gibt. Führe den Test aus Schritt 2 bis Schritt 4 in deinem eigenen Repo aus, denn der Token-Verbrauch hängt stark von deiner Codebase-Größe, deiner MCP-Konfiguration und der Form deiner Aufgabe ab.

Kann ich DeepSeek Harness und OpenCode gegen denselben API-Schlüssel laufen lassen?

Ja, und für einen lockeren Test ist das völlig in Ordnung. Für eine saubere Messung verwende zwei getrennte Schlüssel – einen pro Harness. Dann ordnet das Nutzungs-Dashboard deines Providers jeden Token automatisch dem richtigen Lauf zu, und du musst nie zwei verschiedene interne Schätzer gegen eine Rechnung abgleichen.

Was ist der Unterschied zwischen einem Agenten und einem Harness?

DeepSeeks eigene Formulierung lautet: Agent = Modell + Harness. Das Modell denkt. Der Harness ist alles, was es mit der Realität verbindet: Dateien lesen und schreiben, Shell-Befehle ausführen, Tools aufrufen, Sessions verwalten, Freigaben handhaben und die Loop antreiben, die entscheidet, was als Nächstes passiert. Dasselbe Modell plus ein anderer Harness ergibt einen messbar anderen Agenten – genau darum geht es in diesem Vergleich.