DeepSeek Harness vs OpenCode: De kloof in tokenverbruik die de meeste ontwikkelaars over het hoofd zien

Je hebt een goedkoop model gekozen. Je hebt de berekening op de modelkaart gedaan. Toen kwam de rekening en die zag er heel anders uit dan jouw berekening.

Die kloof wordt bijna nooit veroorzaakt door het model. Het is het harnas. Het harnas bepaalt hoe vaak je model wordt aangeroepen, hoeveel van het gesprek wordt herhaald bij elke aanroep, hoe groot de toolschema's zijn, en of een mislukte testrun drie of twaalf keer wordt overgedaan. Hetzelfde model, dezelfde taak, twee harnassen, enorm verschillende tokenaantallen.

Op 13 augustus 2026 heeft DeepSeek zijn eigen agentharnas open source gemaakt en de discussie werd snel hevig. De ene kant heeft een twee weken oude repo van het lab dat het model bouwt. De andere kant heeft OpenCode, de meest gestarrette coderingsagent op GitHub. Beide zijn MIT. Beide draaien elk model waar je ze naar verwijst.

Dus dit is de eerlijke versie van de vergelijking. Geen sfeer, geen sterren. Wat elke tool daadwerkelijk doet met jouw tokenverbruik, en hoe je het op je eigen repo kunt meten in ongeveer vijftien minuten.

Belangrijkste conclusies

• DeepSeek Harness is een plugin-first agent runtime van DeepSeek AI, MIT-licentie, geschreven in TypeScript, nog steeds gelabeld als developer preview. Modellen, tools, sessies, opslag, sandboxes, loops en zelfs de agentloop zelf zijn verwisselbare plugins.
• OpenCode is een Go, terminal-native coderingsagent met ongeveer 198k GitHub-sterren, een volwassen TUI, LSP-ondersteuning en een grote providercatalogus. Het is vandaag de dag de veilige standaard.
• De keuze van het harnas beïnvloedt het tokenverbruik meer dan de meeste mensen verwachten. In een benchmark van 30 workflows op DeepSeek V4 Flash varieerden de geteste harnassen van ongeveer 192.000 tot 1.400.000 gemiddelde tokens per taak.
• DeepSeek Harness zat niet in die benchmark. Het is twee dagen na publicatie gelanceerd, dus iedereen die nu benchmarkcijfers van het Harness citeert, gokt.
• Beide zijn modelagnostisch, dus je kunt beide naar één OpenAI-compatibel endpoint verwijzen en een echte like-for-like-test uitvoeren. Dat is het enige getal dat ertoe doet voor jouw codebase.

Twee laptops naast elkaar op een zonnige tafel die dezelfde codeertaak uitvoeren via twee verschillende agentharnassen

De enige eerlijke manier om DeepSeek Harness vs OpenCode te draaien: één model, één taak, twee terminals.

Waarom DeepSeek Harness vs OpenCode de discussie van de maand werd

De framing van DeepSeek is een slogan: Agent = Model + Harnas. Het model denkt, het harnas leest bestanden, voert de terminal uit en roept tools aan. Twee jaar lang optimaliseerde iedereen de eerste helft en behandelde de tweede helft als loodgieterswerk.

Het loodgieterswerk bleek duur te zijn.

Composio heeft 30 complexe multi-app-workflows uitgevoerd via 8 verschillende agentharnassen, allemaal met hetzelfde DeepSeek V4 Flash-model, met een limiet van 900 seconden per taak en binaire programmatische beoordeling over 240 runs (Composio, augustus 2026). Overal hetzelfde model. De resultaten waren niet dicht bij elkaar.

Lees de tokenkolom opnieuw. Het meest zuinige harnas gebruikte ongeveer een zevende van de tokens van het meest verspillende, terwijl het identieke model op identieke taken draaide. De eigen conclusie van de benchmark was dat harnassen "net zo belangrijk kunnen zijn als de modellen die ze draaien."

Nu het deel dat de meeste artikelen overslaan. DeepSeek Harness staat niet in die tabel. De benchmark werd op 11 augustus gepubliceerd en het Harnas landde op 13 augustus. Er is nog geen geloofwaardig head-to-head tokencijfer voor DeepSeek Harness, en iedereen die je er deze maand een laat zien, heeft het zelf uitgevoerd op een smalle taak of het verzonnen. Wat de tabel je wel geeft, is een solide, onderbouwde basislijn voor OpenCode: 692.000 tokens per taak, 46,7% slaagpercentage, 129,7 seconden mediaan.

Dat is het getal dat je probeert te verslaan, en de rest van dit artikel gaat over hoe je het eerlijk kunt testen.

DeepSeek Harness vs OpenCode: hetzelfde model, één endpoint, twee runtimes

Hier is de praktische vorm van elke tool voordat we iets uitvoeren.

De belangrijke regel is de architectuurrij. OpenCode geeft je een goed gebouwde agent en laat je de randen uitbreiden. DeepSeek Harness geeft je een skelet en laat je de ruggengraat vervangen, inclusief de agentloop, die zelf een plugin is. Dat is echt ongewoon, en het is ook waarom het nog een preview is.

Beide zijn modelagnostisch, en dat is de hele reden waarom een eerlijke test mogelijk is. Wijs beide naar één OpenAI-compatibel endpoint dat één model serveert en elk verschil dat je meet, is van het harnas.

Voor deze walkthrough gebruik ik DeepSeek V4 Flash via Atlas Cloud, omdat het een gewoon OpenAI-compatibel endpoint biedt dat beide harnassen accepteren zonder adaptercode, en dezelfde sleutel werkt voor beide runs. De deepseek-v4-flash-0731 listing daar is $0,14 per miljoen invoertokens en $0,28 per miljoen uitvoertokens, met een contextvenster van 1.048.576 tokens en maximaal 393.216 uitvoertokens, vanaf augustus 2026. Elke OpenAI-compatibele provider werkt voor deze test. Het punt is dat beide harnassen dezelfde moeten raken.

Het is goed om te weten voordat je een model kiest: OpenCode publiceert zijn eigen geaggregeerde gebruiksgegevens, en DeepSeek-modellen hebben er 233 biljoen tokens doorheen verplaatst, met V4 Flash goed voor 85,5% daarvan en V4 Pro voor de resterende 14,5% (OpenCode, augustus 2026). Flash is waar het ecosysteem daadwerkelijk op draait.

Stap 1: Wijs DeepSeek Harness vs OpenCode naar hetzelfde model

Haal één API-sleutel en één basis-URL, en voer beide tools met exact hetzelfde paar. Maak de sleutel aan in de Atlas Cloud-console en exporteer deze eenmalig:

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

Voordat je een van beide harnassen aansluit, controleer je het endpoint en de exacte model-id met één aanroep. Als dit geen tekst retourneert, werkt niets stroomafwaarts:

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": "Antwoord met het enkele woord: klaar"}]
7  }'
8

Het helpt om het model de echte taak een keer te zien beantwoorden, rechtstreeks via het endpoint, voordat je het aan een agent geeft. Dan weet je dat een mislukte run door het harnas komt en niet door de route:

De taakprompt van het artikel geplaatst naar api.atlascloud.ai, naast het echte antwoord dat DeepSeek V4 Flash 0731 retourneerde en het tokenverbruik dat de aanroep rapporteerde

Een echte aanroep naar deepseek-ai/deepseek-v4-flash-0731, dezelfde model-id die beide harnassen zullen gebruiken: 148 prompt-tokens in, 6.879 uitvoertokens terug, waarvan 5.731 redeneren. Dat is je basis voordat een harnas een enkel toolschema toevoegt.

Configureer nu elke kant. DeepSeek Harness leest $DSH_HOME/settings.yaml, en aangepaste OpenAI-compatibele providers worden geplaatst onder de llm-pi-ai-plugin (DeepSeek Harness-documentatie, augustus 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

Het api-veld accepteert openai-completions, openai-responses of anthropic-messages. Gebruik hier openai-completions. Als je liever geen YAML met de hand bewerkt, heeft de web UI Instellingen, vervolgens Modellen en dan Een aangepaste provider toevoegen, wat hetzelfde blok schrijft en de sleutel opslaat in $DSH_HOME/.credentials.yaml.

OpenCode leest opencode.json in de projectroot of de globale configuratiemap (OpenCode-documentatie, augustus 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

Gebruik @ai-sdk/openai-compatible, niet @ai-sdk/openai, aangezien dit endpoint /v1/chat/completions serveert. Stel de limit-waarden in op de echte context- en uitvoercijfers, omdat OpenCode ze gebruikt om te beslissen wanneer te samenvatten, en een verkeerde limiet zal je tokenvergelijking flink vertekenen.

Stap 2: Voer de benchmarktaak uit in DeepSeek Harness

Kies één taak die groot genoeg is om meerdere toolaanroepen nodig te hebben en klein genoeg om objectief te beoordelen. Multi-bestand, plus een testsuite die daadwerkelijk moet slagen. Gebruik dezelfde repo-status voor beide runs, dus commit of stash eerst.

Dit is de exacte taakprompt. Plak hem letterlijk in beide harnassen:

textCopy
1Voeg in deze repository een token-bucket rate limiter middleware toe voor de Express
2app in src/server.js. Beperk elk IP-adres tot 60 verzoeken per minuut. Bij afwijzing,
3retourneer HTTP 429 met de JSON-body {"error":"rate_limited","retryAfter":<seconden>}.
4Sluit de middleware aan op elke /api/*-route. Voeg unittesten toe in
5test/rate-limit.test.js die drie gevallen dekken: een verzoek onder de limiet wordt
6toegestaan, een verzoek boven de limiet wordt geblokkeerd met 429, en de teller
7wordt gereset nadat het venster is verlopen. Voer de testsuite uit en los fouten op
8totdat deze slaagt. Wijzig geen bestand buiten src/ en test/.
9

Start Harness vanuit je projectmap:

bashCopy
1cd /pad/naar/jouw/repo
2npx @deepseek-ai/dsh web
3

Dat serveert de web UI op http://127.0.0.1:3080. Selecteer de atlas-provider en het deepseek-ai/deepseek-v4-flash-0731-model, plak de taak en laat het voltooien. Grijp niet in, beantwoord geen verhelderende vragen met hints. Elke hulp die je het ene harnas geeft en niet het andere, maakt de vergelijking ongeldig.

Wanneer het klaar is, open je de Trajectory-weergave. Dat is het sessieverslag, en daar staan de tokencijfers.

Stap 3: Herhaal de run in OpenCode voor een eerlijke DeepSeek Harness vs OpenCode-test

Zet de repo terug naar exact dezelfde startstatus. Dit is de stap waar de meeste informele vergelijkingen stilletjes breken, omdat het tweede harnas begint op een repo die het eerste al half heeft gefixt.

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

Voer vervolgens OpenCode uit tegen hetzelfde model:

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

Plak de identieke taakprompt uit Stap 2. Gebruik de standaard build-agent, aangezien die volledige bestands- en shell-toegang heeft. Wederom geen hints, geen koerscorrecties, dezelfde hands-off-behandeling.

Laat het voltooien en controleer vervolgens beide runs op dezelfde manier als je elke PR zou beoordelen:

bashCopy
1npm test
2

Een run die de suite rood achterlaat, is niet geslaagd, hoe zelfverzekerd de samenvatting ook klonk. Beoordeel binair, precies zoals de Composio-methodologie doet. Een halfwerkende rate limiter is een mislukking.

Stap 4: Lees DeepSeek Harness vs OpenCode tokenverbruik

Verzamel nu de cijfers. Beide harnassen houden gebruik bij, maar ze geven het heel anders weer, en dit is het grootste dagelijkse verschil tussen hen.

DeepSeek Harness wordt geleverd met een standaard gemonteerde tokenmeter. Het toont drie sessieprojecties die je direct kunt lezen: tokenUsage voor het lopende totaal, contextPressure voor hoe dicht je bij het venster bent, en contextBreakdown voor waar de tokens daadwerkelijk naartoe gingen. Die laatste is de nuttige, omdat het je vertelt of je rekening wordt veroorzaakt door systeemprompt, toolschema's, bestandslezingen of gespreksherhaling. De meter gebruikt een vaste heuristiek van ongeveer één token per vier tekens in plaats van een echte tokenizer, dus behandel het als een sterke schatting, niet als een factuur.

Harness handelt ook een volledige context anders af. In plaats van af te kappen, vouwt de compacteringsengine: het vervangt het model-zichtbare oppervlak door een samenvatting terwijl de volledige log in de persistentielaag blijft. Je verliest tokens uit de prompt, niet geschiedenis uit het verslag.

OpenCode houdt tokens en kosten per sessie bij en geeft ze weer in de statusregel terwijl je werkt. De in-TUI-uitsplitsing is bewust minimaal, wat de reden is dat er een klein ecosysteem van externe analysetools bestaat die de sessiedatabase van OpenCode rechtstreeks lezen om het gebruik uit te splitsen per tool en per cacheratio. Als je een toewijzing per tool wilt, zul je iets moeten installeren.

Voor de vergelijking zelf: vertrouw niet op de eigen teller van een van beide tools als het laatste woord. Gebruik het cijfer van de providerzijde, want dat is wat je daadwerkelijk betaalt:

De schoonste methode is om twee aparte API-sleutels aan te maken, één genaamd harness-test en één genaamd opencode-test, en elk voor precies één run te gebruiken. Vervolgens geeft de gebruiks-pagina van de provider je een onbetwistbare zij-aan-zij-vergelijking zonder schattingsfout. Die truc kost twee minuten en verwijdert elke bron van onenigheid over wiens teller gelijk heeft.

DeepSeek harness tokenverbruik: wat verplaatst de rekening echt

Zodra je echte cijfers hebt, zijn dit de hendels die het aanraken waard zijn. Ze zijn van toepassing op beide harnassen, en ze zijn veel belangrijker dan welke je hebt gekozen.

Gespreksherhaling is meestal de grootste post. Agents sturen het groeiende gesprek opnieuw bij elke stap. Een taak van 40 stappen kost niet 40 prompts, het kost iets dat lijkt op de som van 40 steeds langere prompts. Dit is waarom de benchmark spreiding van 192.000 tot 1.400.000 tokens liep op identiek werk. Harnassen die agressief samenvatten, belanden aan de onderkant van dat bereik.

Cachehits zijn de goedkoopste optimalisatie die beschikbaar is. DeepSeek V4 Flash cachehits worden geprijsd rond $0,0028 per miljoen tokens tegenover $0,14 per miljoen bij een misser, ongeveer 98% goedkoper. Caching werkt alleen wanneer het requestprefix byte voor byte identiek is, wat precies is waarom DeepSeek Harness strikte {{variable}} interpolatie afdwingt met fail-loud-semantiek en een stabiele requestheader behoudt. Een harnas dat je systeemprompt tussen aanroepen door elkaar husselt, verandert stilletjes elke hit in een misser.

Toolschema's reizen mee op elke aanroep. Twintig aangesloten MCP-servers betekent twintig sets schema's in de prompt, voor altijd, of de taak ze nu aanraakt of niet. Koppel los wat deze taak niet nodig heeft voordat je benchmarkt, of je meet je MCP-configuratie in plaats van je harnas.

Overdreven grote toolresultaten vergiftigen de context. Eén cat van een bestand van 3000 regels, of een uitvoerige testrunner die volledige stacktraces dumpt, blijft in het gesprek voor de rest van de run. Harness heeft een optionele metgezel voor het snoeien van resultaten die overdreven grote toolresultaten herschrijft voordat ze worden samengevat. Het is de moeite waard om aan te zetten.

Pogingen zijn onzichtbaar totdat je het aantal aanroepen telt. Een harnas dat een mislukte test drie keer overdoet, besteedt het drievoudige. Vergelijk de kolom met aanroepnummers, niet alleen totale tokens, of je diagnosticeert een herhaallus ten onrechte als een duur model.

Over kosten: de rekenkunde is eenvoudig zodra je een tokenaantal hebt. Tegen het Atlas Cloud-tarief voor DeepSeek V4 Flash kost een taak van 692.000 tokens, met nadruk op invoer, enkele centen. Dat is het goede nieuws over deze hele categorie: het model is goedkoop genoeg dat verspilling van het harnas een efficiëntieprobleem is in plaats van een budgetnoodgeval. Het wordt pas een echt getal wanneer je het vermenigvuldigt met een team, de hele dag, elke dag. Blader door de volledige modelcatalogus als je dezelfde test tegen een tweede model wilt uitvoeren en model-effecten van harnaseffecten wilt scheiden.

Eén kanttekening die je beslissing meer zou moeten vormen dan elk tokencijfer: DeepSeek Harness is uitdrukkelijk in developer preview en de eigen README waarschuwt in hoofdletters dat er compatibiliteitsbrekende wijzigingen zullen komen. Dat is een prima ding om te benchmarken en een riskant ding om deze maand een team op te standaardiseren. OpenCode is de saaie keuze, en saai is een functie wanneer het tegen je productierepo draait.

Veelgestelde vragen

Is DeepSeek Harness beter dan OpenCode?

Nog niet, voor de meeste mensen. OpenCode is volwassen, terminal-native, heeft ongeveer 198k sterren en een grote providercatalogus, en het werkt vandaag. DeepSeek Harness is twee weken oud, in developer preview, en waarschuwt voor breaking changes. Harness is interessanter vanuit architectonisch oogpunt, omdat elk onderdeel, inclusief de agentloop, een vervangbare plugin is. Als je agent-interne onderdelen wilt herschrijven, is Harness daarvoor gebouwd. Als je deze week code wilt verzenden, is OpenCode de juiste keuze.

Werkt DeepSeek Harness alleen met DeepSeek-modellen?

Nee. Het is modelagnostisch. Het wordt geleverd met catalogusproviders voor DeepSeek, Anthropic, OpenAI, Bedrock, Vertex, Azure en Codex, en je kunt elke aangepaste provider toevoegen die openai-completions, openai-responses of anthropic-messages spreekt door een blok toe te voegen aan $DSH_HOME/settings.yaml. De configuratie in Stap 1 verwijst het naar een externe OpenAI-compatibel endpoint zonder adaptercode.

Hoe controleer ik het DeepSeek harness tokenverbruik?

Gebruik de ingebouwde tokenmeter, die standaard is gemonteerd en tokenUsage, contextPressure en contextBreakdown projecties toont, zichtbaar in de Trajectory-weergave. Houd er rekening mee dat het schat met een vaste heuristiek van ongeveer één token per vier tekens in plaats van een echte tokenizer te draaien. Voor factuurnauwkeurigheid lees je het gebruiksdashboard van je provider, idealiter met een speciale API-sleutel per run. Community-plugins zoals token usage dashboards voegen persistente per-sessie records toe bovenop.

Welk harnas gebruikt minder tokens, DeepSeek Harness of OpenCode?

Er is nog geen gepubliceerde head-to-head. De 8 harnassenbenchmark op DeepSeek V4 Flash mat OpenCode op 692.000 gemiddelde tokens per taak, maar het draaide twee dagen voordat DeepSeek Harness werd uitgebracht, dus Harness was niet opgenomen. Iedereen die een Harness-cijfer uit die benchmark citeert, citeert iets dat niet bestaat. Voer de Stap 2 tot Stap 4-test uit op je eigen repo, aangezien het tokenverbruik sterk afhankelijk is van je codebase-grootte, je MCP-configuratie en de vorm van de taak.

Kan ik DeepSeek Harness en OpenCode tegen dezelfde API-sleutel draaien?

Ja, en voor een informele test is dat prima. Gebruik voor een schone meting twee aparte sleutels, één per harnas. Dan wijst het gebruiksdashboard van je provider elk token automatisch toe aan de juiste run en hoef je nooit twee verschillende interne schatters tegen één factuur te verzoenen.

Wat is het verschil tussen een agent en een harnas?

DeepSeek's eigen framing is Agent = Model + Harnas. Het model doet het redeneren. Het harnas is alles wat het verbindt met de werkelijkheid: bestanden lezen en schrijven, shell-opdrachten uitvoeren, tools aanroepen, sessies beheren, goedkeuringen afhandelen en de loop aansturen die bepaalt wat er gebeurt. Hetzelfde model plus een ander harnas geeft je een meetbaar andere agent, en dat is het hele punt van deze vergelijking.