DeepSeek Harness vs OpenCode: Tokenanvändningsgapet som de flesta utvecklare missar

Du valde en billig modell. Du räknade på modellkortet. Sedan kom fakturan och den såg inte alls ut som din uträkning.

Den luckan beror nästan aldrig på modellen. Det är ramverket. Ramverket avgör hur många gånger din modell anropas, hur mycket av konversationen som spelas upp för varje anrop, hur stora verktygsschemana är, och om ett misslyckat testförsök försöks om tre gånger eller tolv. Samma modell, samma uppgift, två ramverk – helt olika tokenantal.

Den 13 augusti 2026 släppte DeepSeek sitt eget agentramverk som öppen källkod och debatten blev genast het. Ena sidan har ett två veckor gammalt repo från labbet som bygger modellen. Andra sidan har OpenCode, den mest stjärnmärkta kodningsagenten på GitHub. Båda är MIT-licensierade. Båda kör vilken modell du än pekar dem mot.

Så detta är den ärliga versionen av jämförelsen. Inte vibbar, inte stjärnor. Vad var och en faktiskt gör med din tokenanvändning, och hur du mäter det på ditt eget repo på cirka femton minuter.

Viktiga slutsatser

• DeepSeek Harness är en plugin-baserad agentkörningsmiljö från DeepSeek AI, MIT-licensierad, skriven i TypeScript, fortfarande märkt som utvecklarförhandsvisning. Modeller, verktyg, sessioner, lagring, sandlådor, loopar och till och med agentloopen själv är utbytbara plugin-program.
• OpenCode är en Go-baserad, terminalnativ kodningsagent med cirka 198k GitHub-stjärnor, ett moget TUI, LSP-stöd och en stor leverantörskatalog. Det är den säkra standarden idag.
• Val av ramverk påverkar tokenanvändningen mer än de flesta förväntar sig. I en benchmark med 30 arbetsflöden på DeepSeek V4 Flash varierade de testade ramverken från cirka 192 000 till 1 400 000 genomsnittliga tokens per uppgift.
• DeepSeek Harness fanns inte med i den benchmarken. Den lanserades två dagar efter att benchmarken publicerades, så alla som nu citerar siffror för Harness benchmark gissar.
• Båda är modellagnostiska, så du kan peka båda mot en OpenAI-kompatibel slutpunkt och köra en genuin likvärdig jämförelse. Det är den enda siffran som spelar roll för din kodbas.

Två bärbara datorer sida vid sida på ett solbelyst skrivbord som kör samma koduppgift genom två olika agentramverk

Det enda rättvisa sättet att köra DeepSeek Harness vs OpenCode: en modell, en uppgift, två terminaler.

Varför DeepSeek Harness vs OpenCode blev månadens hetaste debatt

DeepSeek's formulering är en slogan: Agent = Modell + Ramverk. Modellen tänker, ramverket läser filer, kör terminalen och anropar verktyg. I två år optimerade alla den första halvan och behandlade den andra som rördragning.

Rördragningen visade sig vara dyr.

Composio körde 30 komplexa arbetsflöden med flera appar genom 8 olika agentramverk, alla med samma DeepSeek V4 Flash-modell, med en tidsgräns på 900 sekunder per uppgift och binär programmatisk bedömning över 240 körningar (Composio, augusti 2026). Samma modell överallt. Resultaten var inte ens i närheten.

Läs tokenkolumnen igen. Det mest sparsamma ramverket använde ungefär en sjundedel av tokenerna jämfört med det mest slösaktiga, med samma modell och samma uppgifter. Benchmarkens egen slutsats var att ramverk "kan vara lika viktiga som modellerna de kör."

Nu kommer delen som de flesta artiklar hoppar över. DeepSeek Harness finns inte i den tabellen. Benchmarken publicerades den 11 augusti och Harness lanserades den 13 augusti. Det finns inga trovärdiga direkta jämförelsesiffror för DeepSeek Harness än, och alla som visar dig en sådan den här månaden har antingen kört den själva på en snäv uppgift eller hittat på den. Det tabellen ger dig är en solid, källbaserad baslinje för OpenCode: 692 000 tokens per uppgift, 46,7% godkännandegrad, 129,7 sekunders median.

Det är den siffran du försöker slå, och resten av denna artikel handlar om hur du testar det ärligt.

DeepSeek Harness vs OpenCode: samma modell, en slutpunkt, två körningar

Här är den praktiska formen av varje verktyg innan vi kör något.

Den viktiga raden är arkitekturraden. OpenCode ger dig en välbyggd agent och låter dig utöka kanterna. DeepSeek Harness ger dig ett skelett och låter dig byta ut ryggraden, inklusive agentloopen, som i sig är ett plugin. Det är verkligen ovanligt, och det är också anledningen till att det fortfarande är en förhandsvisning.

Båda är modellagnostiska, och det är hela anledningen till att en rättvis jämförelse är möjlig. Peka båda mot en OpenAI-kompatibel slutpunkt som kör en modell och varje skillnad du mäter tillhör ramverket.

För denna genomgång använder jag DeepSeek V4 Flash från Atlas Cloud, eftersom det exponerar en vanlig OpenAI-kompatibel slutpunkt som båda ramverken accepterar utan någon adapterkod, och samma nyckel fungerar för båda körningarna. Listningen för deepseek-v4-flash-0731 där är $0,14 per miljon inmatningstokens och $0,28 per miljon utmatningstokens, med ett kontextfönster på 1 048 576 tokens och max 393 216 utmatning, från och med augusti 2026. Vilken OpenAI-kompatibel leverantör som helst fungerar för detta test. Poängen är att båda ramverken måste träffa samma.

Värt att veta innan du väljer en modell: OpenCode publicerar sina egna aggregerade användningsdata, och DeepSeek-modeller har flyttat 233 biljoner tokens genom det, där V4 Flash står för 85,5% av detta och V4 Pro de resterande 14,5% (OpenCode, augusti 2026). Flash är vad ekosystemet faktiskt kör på.

Steg 1: Peka DeepSeek Harness och OpenCode mot samma modell

Skaffa en API-nyckel och en bas-URL, mata sedan båda verktygen med exakt samma par. Skapa nyckeln i Atlas Cloud-konsolen och exportera den en gång:

bashCopy
1export ATLAS_API_KEY="din-api-nyckel"
2

Innan du kopplar upp något av ramverken, kontrollera slutpunkten och det exakta modell-ID:t med ett anrop. Om detta inte returnerar text, kommer inget längre fram att fungera:

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": "Svara med endast ordet: redo"}]
7  }'
8

Det hjälper att se modellen svara på den verkliga uppgiften en gång, direkt via slutpunkten, innan du ger den till en agent. Då vet du att en misslyckad körning beror på ramverket och inte på vägen:

Artikelns uppgiftsuppmaning skickad till api.atlascloud.ai, bredvid det verkliga svaret som DeepSeek V4 Flash 0731 returnerade och tokenanvändningen som anropet rapporterade

Ett verkligt anrop till deepseek-ai/deepseek-v4-flash-0731, samma modell-ID som båda ramverken kommer att använda: 148 inmatningstokens in, 6 879 utmatningstokens tillbaka, varav 5 731 är resonemang. Det är din golvnivå innan ett ramverk lägger till ett enda verktygsschema.

Konfigurera nu varje sida. DeepSeek Harness läser $DSH_HOME/settings.yaml, och anpassade OpenAI-kompatibla leverantörer läggs under plugin-programmet llm-pi-ai (DeepSeek Harness-dokumentation, augusti 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

Fältet api accepterar openai-completions, openai-responses eller anthropic-messages. Använd openai-completions här. Om du hellre inte vill redigera YAML manuellt har webbgränssnittet Inställningar, sedan Modeller, sedan Lägg till anpassad leverantör, vilket skriver samma block och lagrar nyckeln i $DSH_HOME/.credentials.yaml istället.

OpenCode läser opencode.json i din projektrot eller globala konfigurationskatalog (OpenCode-dokumentation, augusti 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

Använd @ai-sdk/openai-compatible, inte @ai-sdk/openai, eftersom denna slutpunkt betjänar /v1/chat/completions. Ställ in limit-värdena till de verkliga kontext- och utmatningsnumren, eftersom OpenCode använder dem för att bestämma när det ska sammanfatta, och en felaktig gräns kommer att snedvrida din tokenjämförelse rejält.

Steg 2: Kör benchmarkuppgiften i DeepSeek Harness

Välj en uppgift som är tillräckligt stor för att kräva flera verktygsanrop och tillräckligt liten för att bedömas objektivt. Flera filer, plus en testsvit som faktiskt måste godkännas. Använd samma repotillstånd för båda körningarna, så commita eller stash först.

Detta är den exakta uppgiftsuppmaningen. Klistra in den ordagrant i båda ramverken:

textCopy
1I detta repo, lägg till en token-bucket rate limiter middleware för Express-appen i src/server.js. Begränsa varje IP till 60 förfrågningar per minut. Vid avvisning, returnera HTTP 429 med JSON-kroppen {"error":"rate_limited","retryAfter":<sekunder>}. Koppla in middlewaren i varje /api/*-rutt. Lägg till enhetstester i test/rate-limit.test.js som täcker tre fall: en förfrågan under gränsen tillåts, en förfrågan över gränsen blockeras med 429, och räknaren återställs efter att fönstret har löpt ut. Kör testsviten och åtgärda fel tills den godkänns. Ändra inte någon fil utanför src/ och test/.

Starta Harness från din projektkatalog:

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

Det betjänar webbgränssnittet på http://127.0.0.1:3080. Välj leverantören atlas och modellen deepseek-ai/deepseek-v4-flash-0731, klistra in uppgiften och låt den köra till slutförande. Ingrip inte, svara inte på förtydligande frågor med ledtrådar. All hjälp du ger det ena ramverket och inte det andra ogiltigförklarar jämförelsen.

När den är klar, öppna Trajectory-vyn. Det är sessionsposten, och där finns token-siffrorna.

Steg 3: Upprepa körningen i OpenCode för en rättvis DeepSeek Harness vs OpenCode-jämförelse

Återställ repot till exakt samma starttillstånd. Detta steget är där de flesta informella jämförelser tyst bryts, eftersom det andra ramverket startar på ett repo som det första redan har halvt fixat.

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

Kör sedan OpenCode mot samma modell:

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

Klistra in den identiska uppgiftsuppmaningen från Steg 2. Använd standardagenten build, eftersom det är den med full fil- och shellåtkomst. Återigen, inga ledtrådar, inga kurskorrigeringar, samma hands-off-behandling.

Låt den slutföras, verifiera sedan båda körningarna på samma sätt som du skulle bedöma vilken PR som helst:

bashCopy
1npm test
2

En körning som lämnar testsviten röd har inte godkänts, oavsett hur självsäker sammanfattningen lät. Bedöm binärt, precis som Composio-metoden gör. En halvfungerande rate limiter är ett misslyckande.

Steg 4: Läs av tokenanvändning för DeepSeek Harness vs OpenCode

Samla nu in siffrorna. Båda ramverken spårar användning, men de presenterar den väldigt olika, och detta är den enskilt största dagliga skillnaden mellan dem.

DeepSeek Harness levereras med en tokenmätare som är monterad som standard. Den exponerar tre sessionsprognoser som du kan läsa direkt: tokenUsage för den löpande summan, contextPressure för hur nära du är fönstret, och contextBreakdown för var tokenerna faktiskt tog vägen. Den sista är den mest användbara, eftersom den berättar om din faktura kommer från systemmeddelande, verktygsscheman, filläsningar eller konversationsuppspelning. Mätaren använder en fast heuristik på ungefär en token per fyra tecken snarare än en verklig tokenizer, så behandla det som en stark uppskattning, inte en faktura.

Harness hanterar också en full kontext annorlunda. Istället för att trunkera, viker dess komprimeringsmotor: den ersätter den modellsynliga ytan med en sammanfattning medan den fullständiga loggen finns kvar i beständighetslagret. Du förlorar tokens från prompten, inte historik från posten.

OpenCode spårar tokens och kostnad per session och skriver ut dem i statusraden medan du arbetar. Den inbyggda nedbrytningen i TUI är minimal, vilket är anledningen till att det finns ett litet ekosystem av externa analysatorer som läser OpenCodes sessionsdatabas direkt för att bryta ner användning per verktyg och per cacheträff. Om du vill ha en attribuering per verktyg måste du installera något.

För själva jämförelsen, lita inte på något av verktygens egna räknare som slutgiltigt svar. Använd leverantörens siffra, eftersom det är den du faktiskt betalar för:

Den renaste metoden är att skapa två separata API-nycklar, en med namnet harness-test och en med opencode-test, och använda varje för exakt en körning. Då ger leverantörens egen användningssida en oomtvistlig sida vid sida med noll uppskattningsfel. Det tricket tar två minuter och eliminerar varje källa till oenighet om vems räknare som har rätt.

DeepSeek Harness tokenanvändning: vad som faktiskt påverkar fakturan

När du väl har verkliga siffror är det dessa spakar som är värda att röra. De gäller för båda ramverken och spelar mycket större roll än vilket du valde.

Konversationsuppspelning är vanligtvis den största posten. Agenter skickar den växande konversationen på nytt vid varje steg. En uppgift med 40 steg kostar inte 40 promptar, den kostar något i närheten av summan av 40 allt längre promptar. Det är därför benchmarkspridningen gick från 192 000 till 1 400 000 tokens på identiskt arbete. Ramverk som sammanfattar aggressivt hamnar i botten av det spannet.

Cacheträffar är den billigaste optimeringen som finns. DeepSeek V4 Flash-cacheträffar prissätts till cirka $0,0028 per miljon tokens jämfört med $0,14 per miljon vid en miss, vilket är cirka 98 % billigare. Cachning fungerar bara när förfrågningsprefixet är byte för byte identiskt, vilket är exakt anledningen till att DeepSeek Harness tvingar strikt {{variable}}-interpolation med hög ljudnivå vid fel och håller en stabil förfrågningsheader. Ett ramverk som blandar om ditt systemmeddelande mellan anrop förvandlar tyst varje träff till en miss.

Verktygsscheman följer med i varje enskilt anrop. Tjugo MCP-servrar anslutna innebär tjugo uppsättningar scheman i prompten, för alltid, oavsett om uppgiften rör dem eller inte. Koppla bort vad denna uppgift inte behöver innan du benchmarkar, annars mäter du din MCP-konfiguration snarare än ditt ramverk.

För stora verktygsresultat förgiftar kontexten. En cat av en 3000-raders fil, eller en utförlig testkörning som dumpar fulla stackspår, sitter i konversationen resten av körningen. Harness har en valfri resultatbeskärningskompanjon som skriver om överdimensionerade verktygsresultat innan sammanfattning. Det är värt att slå på.

Försök är osynliga tills du räknar anropen. Ett ramverk som försöker ett misslyckat test tre gånger lägger tre gånger så mycket. Jämför anropskolumnen, inte bara totala tokens, annars misstolkar du en försöksloop som en dyr modell.

När det gäller kostnad, är aritmetiken enkel när du väl har ett tokenantal. Till Atlas Cloud-priset för DeepSeek V4 Flash landar en uppgift på 692 000 tokens med tyngdpunkt på inmatning i låga ensiffriga cent. Det är de goda nyheterna för hela denna kategori: modellen är tillräckligt billig för att slöseri med ramverket är ett effektivitetsproblem snarare än en budgetkris. Det blir en verklig siffra först när du multiplicerar med ett team, som kör hela dagen, varje dag. Bläddra i den fullständiga modellkatalogen om du vill köra samma test mot en annan modell och separera modellens effekter från ramverkets effekter.

En varning som borde påverka ditt beslut mer än något tokenantal: DeepSeek Harness är uttryckligen i utvecklarförhandsvisning och dess egen README varnar i versaler att det kommer att finnas brytande ändringar. Det är bra att benchmarka men riskabelt att standardisera ett team på denna månad. OpenCode är det tråkiga valet, och tråkigt är en funktion när det körs mot ditt produktionsrepo.

Vanliga frågor

Är DeepSeek Harness bättre än OpenCode?

Inte än, för de flesta. OpenCode är moget, terminalnativt, har cirka 198k stjärnor och en stor leverantörskatalog, och det fungerar idag. DeepSeek Harness är två veckor gammalt, i utvecklarförhandsvisning och varnar för brytande ändringar. Harness är mer intressant arkitektoniskt, eftersom varje komponent inklusive agentloopen är ett utbytbart plugin. Om du vill skriva om agentens interna delar är Harness byggt för det. Om du vill leverera kod denna vecka, använd OpenCode.

Fungerar DeepSeek Harness bara med DeepSeek-modeller?

Nej. Det är modellagnostiskt. Det levereras med katalogleverantörer för DeepSeek, Anthropic, OpenAI, Bedrock, Vertex, Azure och Codex, och du kan lägga till vilken anpassad leverantör som helst som talar openai-completions, openai-responses eller anthropic-messages genom att lägga till ett block i $DSH_HOME/settings.yaml. Konfigurationen i Steg 1 pekar det mot en tredjeparts OpenAI-kompatibel slutpunkt utan adapterkod.

Hur kontrollerar jag DeepSeek Harness tokenanvändning?

Använd den inbyggda tokenmätaren, som är monterad som standard och exponerar tokenUsage, contextPressure och contextBreakdown-prognoser, synliga i Trajectory-vyn. Notera att den uppskattar med en fast heuristik på cirka en token per fyra tecken snarare än att köra en riktig tokenizer. För faktureringsnoggrannhet, läs din leverantörs användningsdashboard istället, helst med en dedikerad API-nyckel per körning. Community-plugins som tokenanvändningsdashboardar lägger till beständiga sessionsposter ovanpå.

Vilket ramverk använder färre tokens, DeepSeek Harness eller OpenCode?

Det finns ingen publicerad direkt jämförelse än. Benchmarken med 8 ramverk på DeepSeek V4 Flash mätte OpenCode till 692 000 genomsnittliga tokens per uppgift, men den kördes två dagar innan DeepSeek Harness släpptes, så Harness ingick inte. Alla som citerar en Harness-siffra från den benchmarken citerar något som inte finns. Kör Steg 2 till Steg 4-testet på ditt eget repo, eftersom tokenanvändning starkt beror på din kodbasstorlek, din MCP-konfiguration och din uppgiftsform.

Kan jag köra DeepSeek Harness och OpenCode mot samma API-nyckel?

Ja, och för ett enkelt test är det okej. För en ren mätning, använd två separata nycklar, en per ramverk. Då attribuerar din leverantörs användningsdashboard varje token till rätt körning automatiskt och du behöver aldrig avstämma två olika interna uppskattningar mot en faktura.

Vad är skillnaden mellan en agent och ett ramverk?

DeepSeek's egen formulering är Agent = Modell + Ramverk. Modellen utför resonemanget. Ramverket är allt som kopplar den till verkligheten: läsa och skriva filer, köra shellkommandon, anropa verktyg, hantera sessioner, hantera godkännanden och driva loopen som bestämmer vad som händer härnäst. Samma modell plus ett annat ramverk ger dig en mätbart annorlunda agent, vilket är hela poängen med denna jämförelse.