DeepSeek Harness Review: Alle drie runs gemeld als voltooid. Slechts één pagina werkte echt.

154.302 sterren. Elke review die ik las, vertelde me dezelfde drie dingen: alles is een plugin, de sessielog is alleen-toevoegen, en het is een developer preview.

Geen enkele vertelde me hoeveel schijfruimte het opslokt. Of hoeveel RAM een inactieve sessie vasthoudt. Of wat er gebeurt als je het op een endpoint richt dat niet van DeepSeek zelf is.

Dus installeerde ik het en gaf het één taak, drie keer: bouw een live ISS-tracker in een enkel zelfstandig HTML-bestand. Drie verschillende providerconfiguraties, dezelfde prompt, hetzelfde model. Alle drie voltooid. Alle drie drukten een zelfverzekerd "Klaar" af met een opsomming van alles wat ze naar verluidt hadden gecontroleerd.

Toen opende ik de drie pagina's in een browser. Twee daarvan waren kapot.

Belangrijkste conclusies

• npm install @deepseek-ai/dsh trok 531 pakketten en 306 MB op macOS. Geen 1,5 GB, maar ook niet klein, en het dsh-pakket zelf is 172 KB daarvan.
• De dsh-webserver draaide op 35 tot 40 MB RSS met een actieve sessie open, na een piek van ongeveer 212 MB bij het opstarten. Het getal van 500 MB dat mensen noemen, is niet het serverproces.
• De Trajectory-weergave is het echte werk in deze release. Het is een gewone alleen-toevoegen JSONL-gebeurtenisstroom op schijf, en het stelde me in staat om het configuratieprobleem te diagnosticeren in minuten in plaats van uren.
• Twee YAML-regels (compat.thinkingFormat en een echte maxTokens) veranderden dezelfde taak van een 36-stappen, 422-seconden run naar een 15-stappen, 152-seconden run. Geen van beide regels staat op de documentatiesite.
• Elke run meldde succes. Slechts één produceerde een pagina met nul consolefouten. Lees de uitvoer, niet de samenvatting.
• Het is een developer preview, en de README zegt dat in hoofdletters. Beperkte pilot, ja. Productiecontrolepaneel, nee.

Hier is het hele artikel in één afbeelding. Twee ISS-trackerpagina's, dezelfde prompt, hetzelfde model, één configuratieverschil. Links is de run die ik heb afgestemd. Rechts is de run die ik niet heb afgestemd.

Zij-aan-zij vergelijking van twee ISS-trackerpagina's gebouwd door DeepSeek Harness, links met een misvormde wereldkaart en een verouderde badge, rechts correct weergegeven met een live marker

Links: de afgestemde run, 152 seconden, vijftien misvormde SVG-paden en een badge vastgelopen op "Stale". Rechts: de naïeve run, 422 seconden, nul consolefouten. Beide meldden klaar.

Waarom Elke DeepSeek Harness Review Dezelfde Drie Dingen Zegt

De repo ging op 13 augustus live en tegen de tijd dat ik begon met schrijven stond hij op 154.302 sterren en 15.960 forks onder een MIT-licentie (GitHub, augustus 2026). Bij dat tempo is de meeste dekking een lezing van de README, omdat er geen tijd is geweest voor iets anders.

Dus het bestaande DeepSeek Harness reviewlandschap valt uiteen in drie kampen, en alle drie hebben hetzelfde gat. De bron-audit uitschrijvingen pluizen de plugin-naden uit en draaien nooit een benchmark. De data-uitschrijvingen vergelijken tokentellingen en slaan installatiegrootte en geheugen expliciet over. De enterprise-inkoop stukken komen tot een oordeel met bijna geen gemeten getallen erin.

Niemand installeerde het, voerde een taak volledig uit en opende vervolgens het resultaat.

Ondertussen was de scherpste kritiek niet in een review. Het waren twee opmerkingen in de lanceringsthread, die 737 punten en 309 reacties in vier dagen trok.

Twee letterlijke Hacker News-opmerkingen over DeepSeek Harness-installatiegrootte en inactief geheugengebruik

De twee klachten die deze review daadwerkelijk probeert te controleren, letterlijk geciteerd uit de lanceringsthread.

Gebruiker Kuyawa: "47mb downloaded, 1.5gb after build, wtf?" en, in een bewerking, "35 dependencies make up for 1.4gb, what they are for?" Gebruiker eglintondust, in een subthread over CPU-belasting: "Memory usage definitely is out of hand, have an idle session right now eating 500MB" (Hacker News, augustus 2026).

Dat zijn de twee getallen die ik eerst wilde controleren, omdat ze bepalen of dit ding op je laptop leeft. Beide bleken ingewikkelder dan de citaten suggereren, en een ervan meet iets anders dan wat mensen aannemen. Als je de architectuurprimer nodig hebt voordat dit enigszins logisch is, dat is een ander artikel: wat DeepSeek Harness eigenlijk is.

Hoe Ik Deze DeepSeek Harness Review Heb Opgezet: Eén Taak, Eén Endpoint

De opzet is bewust saai, zodat de variabele de configuratie is, niet de taak.

De taak. Bouw een live ISS-tracker in één zelfstandig index.html. Het heeft een externe API, een kaartweergave, een polling-loop en foutafhandeling nodig, dus het dwingt een echte meerstappen tool-loop af in plaats van een eenmalige code-dump. En cruciaal, ik kan het resultaat openen en meteen zien of het werkt.

Het model. deepseek-ai/deepseek-v4-flash-0731, hetzelfde model in alle drie runs, dus niets in de vergelijking is een modelverschil.

Het endpoint. Dit is het deel dat mensen overslaan. Harness wordt zonder model geleverd. Het heeft een OpenAI-compatibele basis-URL en een sleutel nodig, punt, en het configuratieoppervlak daarvoor is waar al mijn drie problemen vandaan kwamen. Ik draaide het tegen een gehost OpenAI-compatibel endpoint met vlakke DeepSeek-prijzen en geen piekuurtoeslag, wat ertoe doet wanneer je dezelfde taak herhaaldelijk gaat uitvoeren en de rekening vergelijkbaar wilt hebben over runs heen. Elk compatibel endpoint werkt op dezelfde manier.

Eén eerlijke opmerking over die middelste rij, omdat het me later beet: het retourneert {"code":200,"msg":"succeed","data":[...]} in plaats van de standaard OpenAI {"object":"list","data":[...]}-envelop. De data-array is er, dus een tolerante client is prima, maar ga er niet van uit dat elk "OpenAI-compatibel" endpoint byte-identiek is aan de specificatie.

Prijzen zijn afgelezen van de V4 Flash modelpagina op 18 augustus 2026. Geen kortingsbadge op een DeepSeek-model op dit moment, dus niets hier is een tijdelijke prijs.

Stap 1: Installeer DeepSeek Harness en Meet Wat Het Werkelijk Kost

Alles vanaf hier is reproduceerbaar op macOS met Node 22.19+ of 24+ (er is geen 23.x-ondersteuning, en tal van handleidingen krijgen dit verkeerd). Ik draaide Node v24.15.0 en @deepseek-ai/[email protected].

Begin met de quickstart, dat is één commando:

bashCopy
1node -v                        # ^22.19.0 || >=24, niet 23.x
2npx @deepseek-ai/dsh web       # Web-UI op http://127.0.0.1:3080
3

Om een getal te krijgen dat je daadwerkelijk kunt vergelijken met de 1,5 GB-claim, installeer het in een schone map en meet:

bashCopy
1mkdir dsh-size && cd dsh-size && npm init -y
2npm install @deepseek-ai/dsh
3du -sh node_modules
4du -sh node_modules/* | sort -h | tail -8      # waar het gewicht zit
5

Dit is wat dat op mijn machine opleverde:

textCopy
1added 531 packages in 2m
2306M    node_modules
3255     top-level entries in node_modules
4172K    node_modules/@deepseek-ai/dsh          <- het pakket zelf
5
6 13M    node_modules/@shikijs
7 13M    node_modules/openai
8 14M    node_modules/@google/genai
9 17M    node_modules/@img/sharp-libvips-darwin-arm64
10 24M    node_modules/@mistralai/mistralai
11 26M    node_modules/node-pty
12 27M    node_modules/@deepseek-ai
13 34M    node_modules/@opentelemetry
14

Dus: 306 MB, niet 1,5 GB. Het getal van 1,5 GB in die Hacker News-opmerking is een volledige bronbuild, die dev-afhankelijkheden en build-uitvoer over de hele monorepo meetrekt. De runtime-installatie is een vijfde daarvan.

Dat gezegd hebbende, 306 MB voor een coderingsagent is nog steeds veel, en de uitsplitsing verklaart precies waarom mensen geïrriteerd zijn. Je installeert drie verkopers-SDK's die je nooit zult aanroepen (openai, @google/genai, @mistralai/mistralai komen samen op 51 MB), een volledige OpenTelemetry-boom, een native sharp-binary en een syntaxishighlighter. "Alles is een plugin" heeft een verzendkosten, en op dit moment betaal je alles vooraf, ongeacht of je die routes gebruikt.

Voor inactief geheugen start je het webprofiel, open je een sessie, laat je het met rust en lees je RSS:

bashCopy
1npx @deepseek-ai/dsh web --port 3099
2# dan, in een andere shell:
3ps -o pid,rss,command -p $(pgrep -f "dsh web")
4

Eenmaal per minuut bemonsterd gedurende vijf minuten met een actieve sessie open en geen taak actief:

textCopy
1t+0s     101.8 MB     (direct nadat de sessie werd geopend)
2t+60s     37.0 MB
3t+120s    39.8 MB
4t+180s    38.8 MB
5t+240s    35.8 MB
6t+300s    35.0 MB
7

Het raakte ongeveer 212 MB tijdens het opstarten, daalde naar ~102 MB toen de UI verbinding maakte, daarna bracht de garbage collector het naar de 35 tot 40 MB-band en bleef het daar. Dat is niet "uit de hand".

Maar eglintondust heeft niet per se ongelijk, en dit is het deel dat het waard is te begrijpen: het dsh webprofiel is een lokale server plus een browsertabblad. De 35 MB is de server. De UI is een volledige web-app in je browser, en dat geheugen wordt in rekening gebracht bij Chrome, niet bij dsh. Als je een inactieve sessie van 500 MB in Activity Monitor bekijkt, controleer dan welk proces het is toegeschreven voordat je een bug meldt. Volledige installatiedetails staan in de 10 minuten durende installatiewalkthrough.

Echte terminaluitvoer met de DeepSeek Harness-installatievoetafdruk en inactieve geheugenmetingen

De daadwerkelijke metingen, met de opdrachten zichtbaar. 306 MB geïnstalleerd, 35 MB inactief.

Stap 2: Richt DeepSeek Harness op Je Eigen Endpoint

In de UI is dit Instellingen dan Modellen dan Voeg een aangepaste provider toe: provider-ID, basis-URL, protocol, sleutel, modellenlijst. Je kunt het ook direct in $DSH_HOME/settings.yaml schrijven (standaard ~/.dsh/settings.yaml), wat ik deed, omdat de bestandsversie is wat je kunt diffen tussen runs.

Secties in dat bestand zijn gesleuteld op plugin-ID, wat niet voor de hand ligt de eerste keer. Het provider-dictum behoort tot llm-pi-ai, en de standaard modelselectie behoort tot agent-default-model:

yamlCopy
1llm-pi-ai:
2  providers:
3    atlas:
4      displayName: Atlas Cloud
5      api: openai-completions
6      baseURL: https://api.atlascloud.ai/v1
7      apiKeyEnv: ATLAS_API_KEY
8      models:
9        - id: deepseek-ai/deepseek-v4-flash-0731
10
11agent-default-model:
12  provider: atlas
13  model: deepseek-ai/deepseek-v4-flash-0731
14

Dat is de naïeve configuratie, en het is degene waarmee ik begon. Het werkt. Haal een sleutel uit de Atlas-console, export ATLAS_API_KEY=..., en de run gaat door. Merk op dat apiKeyEnv een verwijzing is, niet het geheim, dus er komt nooit een sleutel in dit bestand.

Een detail uit de UI dat gemakkelijk te missen is en oprecht goed is: wanneer de sleutel uit de omgeving komt, wordt het API-sleutelveld weergegeven als Verstrekt door de startomgeving (alleen-lezen). De groene stip naast de provider betekent dat de route is opgelost. De rode stip naast de ingebouwde DeepSeek-provider betekent dat deze geen inloggegevens heeft. Dat is een gezondheidscontrole van twee seconden waar je niet naar hoeft te graven.

Twee dingen aan deze configuratie zijn echter stilletjes fout, en ik kwam er pas achter toen ik trajecten vergeleek. Houd die gedachte vast tot Stap 4.

De DeepSeek Harness Instellingen Modellen-pagina met een aangepaste OpenAI-compatibele provider genaamd Atlas Cloud met een groene statusstip en zijn API-sleutel alleen-lezen verstrekt door de startomgeving

Instellingen, Modellen, aangepaste provider. Groene stip betekent dat de route is opgelost; de ingebouwde DeepSeek-provider erboven is rood omdat deze geen sleutel heeft.

Stap 3: De DeepSeek Harness Review's Drie Runs, Zij aan Zij

Elke keer dezelfde prompt. Plak dit letterlijk als je het wilt reproduceren:

textCopy
1Build a single-page ISS tracker in one self-contained index.html.
2
3Requirements:
4- Fetch the ISS position from https://api.wheretheiss.at/v1/satellites/25544 every 5 seconds.
5- Render a world map with a marker at the current lat/lon, plus a fading trail of the last 60 positions.
6- Show altitude (km), velocity (km/h), and the current lat/lon in a readable panel.
7- No build step, no npm install, no API key. Vanilla JS + inline CSS only.
8- Handle fetch failures without breaking the page: keep the last known position and show a stale badge.
9- Write the file, then report done.
10

Voer het headless uit zodat het transcript schoon is:

bashCopy
1export DSH_HOME=$PWD/dsh-home
2export ATLAS_API_KEY=<your key>
3dsh --profile headless "<the prompt above>"
4

Drie configuraties:

• Run A, de afgestemde: compat.thinkingFormat: deepseek, contextWindow: 1048576, maxTokens: 131072.
• Run B, de naïeve van Stap 2: de modelinvoer is niets anders dan id.
• Run C, de plausibele fout: hetzelfde als A maar met maxTokens: 4096, een getal dat ik rechtstreeks uit de eigen README-voorbeeld van de adapter heb gehaald.

Alle drie eindigden met 0. Alle drie schreven een index.html. Alle drie drukten een samenvatting af die verificatie claimde. De samenvatting van Run C schepte zelfs op over zelfherstel: "A couple of bugs I caught and fixed during the build: an undefined variable in the trail fade, incorrect N/S-E/W suffix logic..."

Toen opende ik alle drie bestanden in een echte browser met de console open, en liet ze twee cycli pollen.

Lees die tabel nog eens. De snelste run en de run die ik zorgvuldig had afgestemd, leverden beide kapotte pagina's op. De langzame, naïeve, duurste run is de enige die werkte.

Het falen van Run A is het leerzame. Het telemetriepaneel was perfect: 431 km hoogte, 27.547 km/u, correcte lat/lon, live updatend. De kaart eronder was een groene vlek, omdat alle vijftien continentpaden eindigden in een losse L zonder coördinaten ("... L48.0 624.0 L Z"). En de badge zei "Stale, keeping last position" met "Last update: -" terwijl drie succesvolle fetches in het netwerktabblad stonden. Het kreeg het moeilijke deel goed en het zichtbare deel fout.

De reden zit in zijn eigen redeneringslogboek, bij stap 12, in zijn eigen woorden: het had een variabele verwijderd die zijn kaartbouwer nog steeds gebruikte, merkte het op, en ging toch verder. Dat soort zelf toegebrachte regressie laat in een run is precies waar een alleen-toevoegen traject goed voor is, wat de volgende stap is.

Run C is grappiger en erger. Het beweerde de trail-fade bug en de N/S-achtervoegsellogica te hebben opgelost. De trail is precies wat kapot is (twaalf NaN-cirkels, geen trail wordt weergegeven), en het breedtegraadlabel leest -34.76° S, wat dubbel getekend is. Het loste geen van de twee dingen op die het zei te hebben opgelost, en het controleerde zijn werk met node --check, dat JavaScript-syntax parseert en niets weet of een SVG-pad legaal is.

De ISS-trackerpagina van de derde run met een NaN-gepositioneerde trail, een marker vast in de linkerbovenhoek en een dubbel getekend breedtegraadlabel

Run C, de 50-seconden run: mooi, live, en stilletjes kapot op de twee plaatsen die het beweerde te hebben opgelost.

Niets hiervan is echt een Harness-bug. Het is een coderingsagent-bug die Harness trouw uitvoerde en vervolgens trouw als succes rapporteerde. Wat ons brengt bij het enige deel van deze release dat me echt onder de indruk bracht.

Stap 4: De Twee-Regel Fix, en de DeepSeek Harness Trajectory View Die Het Vond

Run B die 2,8x langer duurde dan Run A, was voor mij niet logisch. Hetzelfde model, dezelfde taak, en het enige verschil was een paar regels YAML. Dus ik ging naar de Trajectory.

De officiële beschrijving is accuraat, wat zeldzamer is dan het zou moeten zijn: "Everything the model sees is recorded in an append-only session log: system prompts, reasoning, tool calls and results, subagent scheduling, and every context injection... In the Trajectory view, you can inspect these records by source. Resume, fork, search, and replay all operate on the same event stream" (DeepSeek Harness, augustus 2026).

Het is geen marketing. De stream is een echt bestand:

bashCopy
1ls $DSH_HOME/sessions/<workspace>/session-<uuid>/session.jsonl.zstd
2

Eén JSON-gebeurtenis per regel, zstd-omkaderd, alleen-toevoegen. Run A produceerde 606 gebeurtenissen; Run B produceerde 1.709. Filter op bron in de UI, of grep gewoon het gedecodeerde bestand. De gebeurtenistypen zijn precies wat de bovenstaande zin belooft: turn/start, step/start, request/header, request/context, assistant/chunk, reasoning-chunks, tool-call-chunks, tool/call, tool/result, step/end, turn/end.

De request/header-gebeurtenis is wat het oploste. Het registreert de configuratie die daadwerkelijk op de draad werd gezet:

jsoncCopy
1// Run A
2{"config":{"provider":"atlas","model":"deepseek-ai/deepseek-v4-flash-0731","maxTokens":131072},
3 "adapterDefaults":{"maxTokens":true}}
4
5// Run B
6{"config":{"provider":"atlas","model":"deepseek-ai/deepseek-v4-flash-0731"}}
7

Run B stuurde helemaal geen uitvoerlimiet, en zijn redenering zwol op tot 72.420 tekens over 33 blokken tegen Run A's 6.094 over 9. Daar komen de extra 270 seconden en de extra 44.170 uitvoertokens vandaan.

De oorzaak is gedocumenteerd, maar niet op de documentatiesite. Het is begraven in packages/llm/llm-pi-ai/README.md: het denkdialect wordt geraden uit de endpoint-URL. In de eigen woorden van de onderhouders: compat.thinkingFormat is iets dat "pi-ai guesses from the endpoint URL; a private gateway's URL says nothing, so a DeepSeek-dialect gateway would be spoken to in the OpenAI dialect with no way to correct it."

Mijn endpoint retourneert reasoning_content, de DeepSeek-spelling. De hostnaam zegt daar niets over. Dus in Run B viel de adapter terug op het OpenAI-dialect, kon geen denkniveau verzenden, en het model redeneerde op zijn eigen standaard bij elk van de 36 aanroepen. Afzonderlijk erft een modelinvoer die alleen id declareert de route-fallbacks defaultContextWindow: 262144 en defaultMaxTokens: 32768, dus een model met 1.048.576 tokens verliest stilletjes driekwart van zijn venster.

Beide zijn twee regels:

yamlCopy
1llm-pi-ai:
2  providers:
3    atlas:
4      api: openai-completions             # compat.* bestaat ALLEEN onder dit protocol
5      baseURL: https://api.atlascloud.ai/v1
6      apiKeyEnv: ATLAS_API_KEY
7      compat:
8        thinkingFormat: deepseek          # stop met raden uit de URL
9        supportsReasoningEffort: true
10      models:
11        - id: deepseek-ai/deepseek-v4-flash-0731
12          contextWindow: 1048576          # override de 262.144 fallback
13          maxTokens: 131072               # laat redenering echte ruimte
14

Twee dingen om in je hoofd te houden. De resolutievolgorde is model, dan route, dan de geïnstalleerde catalogusinvoer, dan de URL-gok van pi-ai, dus een waarde op modelniveau wint. En compat.* bestaat alleen onder api: openai-completions; zet het ergens anders en resolutie faalt volledig. De adapter ondersteunt ook bewust geen Bedrock, Vertex, Azure of Codex, omdat hun authenticatie meer nodig heeft dan een sleutel, een endpoint en headers.

Stel dat in, en de draadconfiguratie van Run A is correct, de tokenrekening daalt 3,5x, en het levert nog steeds een kapotte kaart af. Dat is de eerlijke samenvatting van deze hele oefening: de configuratie-fix is echt, en het lost de rekening op, niet de codereview die je nog steeds zelf moet doen.

De alleen-toevoegen sessiegebeurtenisstroom van een echte DeepSeek Harness-run, met gebeurtenisaantallen en de verzoekheader die het configuratieprobleem onthulde

De Trajectory-gebeurtenisstroom van Run A: 606 gebeurtenissen, en de ene die de ontbrekende uitvoerlimiet blootlegde.

Wat Deze DeepSeek Harness Review Heeft Gekost, en Of Het Productieklaar Is

Drie volledige agentruns van een niet-triviale taak, rechtstreeks uit de trajecten, tegen het vlakke tarief van $0,14 in / $0,28 uit per 1M:

Twee dingen die het waard zijn om daaruit te halen. Ten eerste, de cache-getallen zijn echt en het endpoint rapporteert ze: 93,8% van alle prompttokens in de drie runs kwamen terug als cache-leesbewerkingen, wat is wat een agent-loop überhaupt betaalbaar maakt. Ten tweede, de verkeerd geconfigureerde run kostte 3,5x de afgestemde voor een taak van identieke grootte. Dat is de werkelijke prijs van de twee YAML-regels.

Merk de vorm op van de eerste aanroep in elke run: ongeveer 11.000 invoertokens voordat de agent iets heeft gedaan. Dat is de systeemprompt, de toolschema's en de vaardighedencatalogus die "alles is een plugin" impliceert, en je betaalt het bij elke nieuwe sessie. Het is waarom de cache-hitratio er meer toe doet op deze harness dan op een dunnere, en waarom een Minimal-mode run (bash plus een bestandseditor alleen) het proberen waard is als je taak niet de volledige toolset nodig heeft.

Dus kun je het in productie zetten? Nee, en het project is het met je eens. De README's eigen woorden: "DeepSeek Harness is currently in developer preview and is iterating rapidly. THERE WILL BE COMPATIBILITY-BREAKING CHANGES." De Web-UI opent met een modal die zegt "DeepSeek Harness 0.1 remains in testing for Harness developers." MIT-licentie betekent dat je kunt doen wat je wilt; het betekent niet dat de API waar je tegen bouwt volgende maand nog bestaat.

De rest van de risicolijst is kort en echt. Er is een anonieme telemetrie-UUID. Plugins en MCP-servers worden uitgevoerd buiten de bash-sandbox, dus een plugin is code die je ervoor kiest te vertrouwen. En zoals deze review op de harde manier vond, zijn de instellingen die kosten en juistheid bepalen, gedocumenteerd in een package README in plaats van de gids, wat betekent dat je eerste rekening meerdere keren kan zijn wat het zou moeten zijn om redenen die geen foutmelding je zal vertellen.

DeepSeek Harness Review: Veelgestelde Vragen

Is DeepSeek Harness productieklaar?

Nee. De README stelt het duidelijk: "DeepSeek Harness is currently in developer preview and is iterating rapidly. THERE WILL BE COMPATIBILITY-BREAKING CHANGES." De Web-UI herhaalt het in een startmodal. Een beperkte pilot op een niet-kritieke werklast is vandaag redelijk. Een productiecontrolepaneel waar je team van afhankelijk is, is dat niet, omdat het API-oppervlak waar je tegen bouwt expliciet onstabiel is.

Hoeveel schijf en geheugen gebruikt DeepSeek Harness daadwerkelijk?

Op macOS trok npm install @deepseek-ai/dsh 531 pakketten en 306 MB, waarvan het dsh-pakket zelf 172 KB is. De veel geciteerde 1,5 GB is een volledige bronbuild, niet de runtime-installatie. Het webserverproces draaide op 35 tot 40 MB RSS met een actieve sessie open, na een piek van bijna 212 MB tijdens het opstarten. Het geheugen van de UI wordt in rekening gebracht bij je browser, niet bij dsh.

Waarom is mijn DeepSeek Harness-run zoveel langzamer en duurder dan verwacht?

Hoogstwaarschijnlijk declareert je modelinvoer niets anders dan id. Dat erft de route-fallbacks defaultContextWindow: 262144 en defaultMaxTokens: 32768, en het laat de adapter het denkdialect raden uit de hostnaam van je endpoint. In mijn test produceerde die combinatie 36 stappen in plaats van 15 en 3,5x de tokenkosten voor dezelfde taak. Stel compat.thinkingFormat, een echte contextWindow en een echte maxTokens in.

Werkt DeepSeek Harness met niet-DeepSeek endpoints?

Ja, elke OpenAI-compatibele basis-URL werkt, en dat is hoe de meeste mensen het zullen uitvoeren. Het addertje onder het gras is dat het denkdialect wordt afgeleid van de URL, dus een DeepSeek-dialect gateway op een neutrale hostnaam wordt aangesproken in het OpenAI-dialect. compat.thinkingFormat: deepseek is de fix, en het bestaat alleen onder api: openai-completions. Bedrock, Vertex, Azure en Codex worden bewust niet ondersteund.

Is de Trajectory-weergave daadwerkelijk nuttig, of is het marketing?

Het is nuttig, en het is het sterkste punt in deze release. De sessielog is een echte alleen-toevoegen JSONL die je kunt filteren op bron, hervatten, forken en herhalen, en de request/header-gebeurtenis vertelde me precies welke configuratie de draad bereikte, wat mijn probleem oploste. Wat het niet doet, is uitleggen waarom het model iets koos. Het registreert wat het model zag, niet waarom het besloot.

DeepSeek Harness vs Claude Code of OpenCode, welke moet ik dagelijks gebruiken?

Als je iets wilt dat betrouwbaar code schrijft vandaag, niet deze, nog niet. Kies Harness wanneer de agent-runtime zelf is wat je wilt veranderen, omdat het verwisselen van de loop, de tools of de UI hier configuratie is in plaats van een fork. Voor een op nummers gebaseerde vergelijking over tokenverbruik, zie DeepSeek Harness vs OpenCode, en voor de extensielaag, welke plugins het installeren waard zijn.

---

Runs uitgevoerd op 18 augustus 2026 op macOS, Node v24.15.0, @deepseek-ai/[email protected], model deepseek-ai/deepseek-v4-flash-0731 bediend via een OpenAI-compatibel endpoint op Atlas Cloud. Elk tokentelling, kloktijd en consolefout in dit artikel kwam uit de sessielogs en browserconsoles van die runs.