DeepSeek Harness vs Hermes: Welke verbruikt meer tokens?

Je hebt gisteren een taak uitgevoerd in Hermes. Vandaag voerde je wat aanvoelde als dezelfde taak uit in dsh. Hetzelfde model, dezelfde API-sleutel, dezelfde laptop. De verbruikscijfers waren toch anders.

Je ogen zijn in orde. Er is niets van prijs veranderd vannacht.

Hier is wat bijna elke DeepSeek Harness vs Hermes-vergelijking mist: de harness is de schil om het model heen, en die schil bepaalt hoeveel context er per stap uitgaat, hoeveel tools hij adverteert, hoe vaak hij opnieuw probeert en of hij het hele gesprek opnieuw verstuurt bij elke aanroep. Verander de schil, verander de rekening.

Dus ik zette de modelvariabele vast en mat het. Twee harnessen, één endpoint, één deepseek-ai/deepseek-v4-pro, één prompt, één machine, één middag. Dezelfde taak, beide voltooid, en één ervan verplaatste 8,4x meer prompttokens dan de andere.

Belangrijkste conclusies

• Hetzelfde model, dezelfde taak, beide geslaagd: dsh deed 121 seconden, Hermes deed 780 seconden.
• Hermes verplaatste 1.111.573 prompttokens tegenover dsh's 132.600. Dat is 8,4x, bij één taak.
• Voordat een van beide agents ook maar iets doet, kost het systeemprompt al tokens: dsh 10.898 vs Hermes 13.892 alleen al om "OK" te antwoorden.
• dsh begrenst je stilletjes op 262.144 context, tenzij je defaultContextWindow overschrijft, en gooit daarmee 75% van V4's venster weg.
• Kies dsh voor coderen, Hermes voor geheugen, cron en chat-oppervlakken. Of gebruik beide.

Gesplitste technische werkplaats met een kale motorblok vastgeklemd in een stalen testopstelling aan de linkerkant en een messing archiveringsautomaat aan de rechterkant, beide gevoed door één koperen brandstofleiding

Eén brandstofleiding, twee testopstellingen. Dat is het hele experiment. Gegenereerd met openai/gpt-image-2.

DeepSeek Harness vs Hermes, Hetzelfde Model, Dezelfde Taak

Beide harnessen kregen dit, woord voor woord: bouw een zelfstandige Breakout-kloon met een paddle, 5 rijen stenen, een live scoreteller, een P-toets om te pauzeren, plus een inline zelftest die drie natuurkundige invarianten controleert en PASS of FAIL afdrukt. Voer het vervolgens headless uit en repareer het totdat alle drie PASS afdrukken.

Geen bibliotheken. Geen CDN. Geen bouwstap.

Beide hebben het daadwerkelijk gedaan. Hier zijn de twee bestanden, weergegeven in een echte browser.

Geanimeerde side-by-side van de twee Breakout-bouwwerken die draaien: DeepSeek Harness (dsh) links, Hermes Agent rechts, beide automatisch afgespeeld vanaf de identieke DeepSeek V4 Pro-prompt

De twee bouwwerken opnieuw opgenomen naast elkaar en automatisch afgespeeld, zodat je kunt zien hoe elk daadwerkelijk draait. Links: dsh, waarvan het spel automatisch start. Rechts: Hermes , waarvan het spel gepauzeerd opstart en dan draait. Dezelfde eenbestandsprompt, dezelfde DeepSeek V4 Pro , twee harnessen.

Nu de cijfers die hier daadwerkelijk over beslissen.

Gemeten op 2026-08-21 op deepseek-ai/deepseek-v4-pro, één machine, lege werkdirectory per run. Tokenaantallen zijn machinaal uitgelezen: dsh's uit zijn sessielog, Hermes' uit zijn --usage-file JSON. Wees je ervan bewust dat de twee tool-aantallen niet op dezelfde manier zijn verkregen: dsh's 8 is geteld uit zijn log (het claimde 6), terwijl Hermes' 35 zijn eigen rapportage is, waarbij het gebruikersbestand 38 API-aanroepen registreert. De kostenmethode wordt uitgelegd in het laatste hoofdstuk.

Waarom de twee lege rijen? Ronde 2 is nooit uitgevoerd, en de reden is het beste datapunt van dit artikel. Alleen Hermes' ronde 1 duwde al 1,13 miljoen tokens door de account, en halverwege dsh's ronde 2 antwoordde het endpoint:

plaintextCopy
1dsh: QUOTA: 429: {"code":"member_spend_limit_exceeded",
2"message":"Member day spend limit reached (set by your team admin);
3resets at 2026-08-22T00:00:00Z.","type":"insufficient_quota"}

Eén agent, één Breakout-spel, één dagbudgetlimiet. Ik ga die cellen niet vullen met schattingen.

Nog een detail dat het vermelden waard is. dsh rapporteerde "Tool calls used: 6" in zijn uiteindelijke antwoord. Zijn eigen sessielogboek registreert 8. Agents zijn onbetrouwbare vertellers over hun eigen uitgaven, en dat is precies waarom deze test logs leest in plaats van samenvattingen.

Waarom de meeste DeepSeek Harness vs Hermes-vergelijkingen kloppen

Eerst het oordeel: bijna elke pagina die voor dit trefwoord scoort, meet de verkeerde variabele, en je kunt het in één regel van hun opzet herkennen.

Het model, niet de schil, is wat die tests hebben gemeten

Ga de topresultaten lezen. Het patroon herhaalt zich: voer dsh uit op een DeepSeek-model, voer Hermes uit op waar Hermes al op gericht was, en schrijf het hele verschil toe aan de harness.

Dat is geen harness-vergelijking. Dat is een modelvergelijking in een harness-vormig jasje.

Als dsh op V4 Pro draait en Hermes op iets anders, dan is de delta die je meet voornamelijk de twee modellen, en de bijdrage van de schil is onherstelbaar begraven. Dus deze test doet het saaie, noodzakelijke: beide harnessen wijzen naar dezelfde basis-URL, hetzelfde model-ID, dezelfde sleutel.

De keuze van de harness verandert de cijfers op zichzelf

Wil je bewijs dat de schil alleen al duur is? Vraag elke om niets te doen.

Ik stuurde beide dezelfde triviale prompt: Reply with exactly the word: OK. Geen tools nodig, geen bestanden, geen denkwerk vereist.

Hetzelfde model. Dezelfde vraag. Een kloof van 2.994 tokens voordat er echt werk begint, omdat die kloof de harness is: zijn systeemprompt, zijn tool-schema's, zijn regelsbestand. Hermes levert meer oppervlakte, dus Hermes levert meer tokens.

Vermenigvuldig dat nu met een agent-lus van 38 aanroepen waarbij elke aanroep het hele gesprek opnieuw verstuurt. Gecachte reads waren 88,8% van dsh's prompttokens en 95,5% van Hermes'. Dat herlezen is de rekening.

Eén Endpoint, Twee Harnessen: De DeepSeek V4-opstelling

Om schelpen te vergelijken moet de modelkant volkomen stil staan. Niet alleen dezelfde modelnaam: hetzelfde endpoint, dezelfde snelheidslimiet, dezelfde prijs om 3 uur 's nachts als om 3 uur 's middags.

Dat laatste is belangrijker dan het klinkt. Als je provider piek- en daluren hanteert, dan zijn "ronde 1 in Hermes om 09:00" en "ronde 2 in dsh om 11:00" niet vergelijkbare runs, en je zult nooit kunnen ontwarren hoeveel van de delta door de harness kwam en hoeveel door de klok.

Dus beide harnessen wijzen hier naar één vast tarief OpenAI-compatibel endpoint op Atlas Cloud: https://api.atlascloud.ai/v1. Dezelfde prijs de hele dag, geen piekvenster, geen aparte wachtrij per harness, één sleutel voor beide.

Prijzen uitgelezen van de modelpagina's op 2026-08-21. Geen kortingsbadge op de DeepSeek-familie op dit moment, dus niets hier is een promotietarief dat volgende week verloopt.

Klein detail dat makkelijk te missen is: /v1/models rapporteert deepseek-v4-pro en deepseek-v4-flash als fp4, terwijl deepseek-v4-pro-0813 terugkomt als fp8. Wil je de hogere precisiegewichten? Gebruik de datum-ID.

Oké. Laten we het bouwen.

Voer de DeepSeek Harness vs Hermes-test zelf uit

Voorbeeld: zeven stappen, twee configuratiebestanden, één prompt, en je eindigt met je eigen versie van die tabel in plaats van de mijne te vertrouwen. Bewijs dat het werkt: elk getal hierboven kwam uit precies deze stappen op een standaard MacBook, Node v24.15.0, dsh 0.1.0-rc.7, Hermes v0.20.4.

Laten we beginnen.

Stap 1: Zorg voor een endpoint dat stabiel blijft

Beide harnessen leunen zwaar op functieaanroepen, dus voordat je iets installeert, bewijs dat het endpoint tools ondersteunt:

plaintextCopy
1curl -s https://api.atlascloud.ai/v1/models \
2  -H "Authorization: Bearer $ATLAS_API_KEY" \
3  | jq '.data[] | select(.id|test("v4-pro$")) | {id, context_length, max_output_length, supported_features}'

Echte uitvoer van die aanroep:

plaintextCopy
1{
2  "id": "deepseek-ai/deepseek-v4-pro",
3  "context_length": 1048576,
4  "max_output_length": 393216,
5  "supported_features": ["json_mode", "tools", "structured_outputs"]
6}

tools in die lijst is waar je naar controleert. Geen tools, geen agent-lus, en beide harnessen zullen op verwarrende manieren falen in plaats van het te melden.

Haal je sleutel van de DeepSeek V4 Pro-modelpagina, en zet dan export ATLAS_API_KEY=... voor elke opdracht hieronder.

Eén valkuil voor de Hermes-kant: het antwoord wikkelt de array in als {"code":200,"msg":"succeed","data":[...]}. Hermes doorzoekt /v1/models tijdens de setup en parseert dit prima, maar als je je eigen tooling ertegen schrijft, verwacht dan geen kale lijst.

Stap 2: Installeer beide agents

plaintextCopy
1# DeepSeek Harness
2npm install @deepseek-ai/dsh
3
4# Hermes Agent
5curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

Drie installatienotities die mij tijd hebben gekost:

• dsh heeft Node ^22.19.0 || >=24.0.0 nodig. Het ondersteunt geen 23.x. De meeste tutorials zeggen "Node 20+", wat gewoonweg fout is.
• Die npm-installatie trok 453 pakketten binnen en duurde 8 minuten. Het is geen kleine afhankelijkheid.
• Hermes brengt zijn eigen Python 3.11 mee via uv, dus je systeem-Python maakt niet uit (de mijne is 3.9). Als de installatie halverwege een PyPI-hickup afbreekt, voer dan de afhankelijkheidssynchronisatie opnieuw uit in plaats van het hele script.

Stap 3: Richt DeepSeek Harness op het endpoint

Schrijf dit in $DSH_HOME/settings.yaml (standaard ~/.dsh):

plaintextCopy
1llm-pi-ai:
2  providers:
3    atlas:
4      displayName: Atlas Cloud
5      apiKeyEnv: ATLAS_API_KEY
6      api: openai-completions
7      baseURL: https://api.atlascloud.ai/v1
8      defaultContextWindow: 1048576
9      defaultMaxTokens: 65536
10      compat:
11        thinkingFormat: deepseek
12      models:
13        - id: deepseek-ai/deepseek-v4-pro
14          name: DeepSeek V4 Pro
15          reasoningEfforts:
16            off:
17            high: high
18        - id: deepseek-ai/deepseek-v4-flash
19          name: DeepSeek V4 Flash
20          reasoningEfforts:
21            off:
22            high: high
23agent-default-model:
24  provider: atlas
25  model: deepseek-ai/deepseek-v4-pro

Drie regels daarin verdienen elk een zin, omdat het verkeerd krijgen ervan je rekening verandert:

1. compat.thinkingFormat: deepseek is de regel die niemand schrijft. dsh raadt het denkdialect uit de endpoint-URL. Zijn eigen adapter-README is er duidelijk over: de URL van een privé-gateway zegt niets, dus een onherkend endpoint wordt aangesproken "alsof het OpenAI zelf is". Je DeepSeek-dialect-gateway wordt dan in OpenAI-dialect aangesproken. Deze sleutel bestaat alleen onder api: openai-completions.
2. Overschrijf defaultContextWindow. De route-niveau terugvalwaarden zijn 262.144 context en 32.768 max tokens. Als je V4-modellen handmatig declareert zonder die aan te raken, heb je stilletjes 75% van een 1.048.576 venster weggegooid.
3. agent-default-model neemt provider en model als twee aparte sleutels. Het schrijven van model: atlas/deepseek-ai/deepseek-v4-pro als één string ziet er redelijk uit en doet niets. Je krijgt MISSING_CREDENTIAL: no API key for provider route "deepseek-official", en je gaat op zoek naar een sleutelprobleem dat je niet hebt.

Merk op dat apiKeyEnv een credential-referentie is, niet het geheim. Er komt geen sleutel in dit bestand.

Stap 4: Richt Hermes op hetzelfde endpoint

De wizardroute is hermes model, kies dan "Custom endpoint". De scriptbare route is vijf commando's:

plaintextCopy
1hermes config set model.provider custom
2hermes config set model.default deepseek-ai/deepseek-v4-pro
3hermes config set model.base_url https://api.atlascloud.ai/v1
4hermes config set model.api_key "$ATLAS_API_KEY"
5hermes config set model.context_length 1048576

Dit schrijft ~/.hermes/config.yaml:

plaintextCopy
1model:
2  provider: custom
3  default: deepseek-ai/deepseek-v4-pro
4  base_url: https://api.atlascloud.ai/v1
5  api_key: apikey-...
6  context_length: 1048576

provider: custom is hier een eersteklas provider, geen alias, en de basis-URL moet eindigen op /v1 omdat Hermes zelf /chat/completions toevoegt (Hermes Agent-documentatie, Configuring Models, 2026).

Sla die api_key-regel niet over. De documentatie zegt dat de sleutel terugvalt op OPENAI_API_KEY, en in mijn run was het exporteren van die variabele niet genoeg: Hermes stuurde het verzoek zonder bruikbare authenticatie en Atlas antwoordde HTTP 401: {"code":401,"msg":"unauthorized"}. Het expliciet instellen van model.api_key loste het bij de volgende poging op, in 8,5 seconden.

Stap 5: Voer ronde 1 uit op beide

Wis eerst Hermes' vaardighedendirectory (~/.hermes/skills). Een bestaande vaardigheid maakt ronde 1 oneerlijk, en bij ronde 2 wil je zien hoe een vaardigheid wordt aangemaakt en vervolgens hergebruikt.

Geef dan beide harnessen dit, byte voor byte:

plaintextCopy
1Create a single self-contained file game.html: a Breakout clone with paddle, 5 rows of bricks,
2a live score counter, and a P key that pauses. No external libraries, no CDN, no build step.
3Then append an inline <script id="selftest"> block that asserts three physics invariants
4(ball reflects on paddle hit, score increments exactly once per brick, ball never leaves the canvas)
5and prints PASS/FAIL to the console. Run it headlessly, fix anything that fails, and stop only
6when all three asserts print PASS. Report the number of tool calls you used.

Instellingen: een verse lege directory per harness, reasoning ingeschakeld, max output minimaal 32.768, en niets anders dat op de machine draait zodat de kloktijden iets betekenen.

plaintextCopy
1# dsh, eenmalige persistente sessie
2DSH_HOME=~/.dsh dsh --profile headless "$(cat prompt-r1.txt)"
3
4# Hermes, eenmalig met een machineleesbaar gebruiksrapport
5hermes -z "$(cat prompt-r1.txt)" --yolo --usage-file hermes-r1-usage.json

Twee dingen zullen je hier verrassen.

Ten eerste, hermes -z drukt absoluut niets af tot het klaar is. Geen banner, geen spinner, geen tool-voorvertoningen. De mijne zat 13 minuten stil en leek vastgelopen; dat was het niet, het was bezig met 38 API-aanroepen. Controleer ps op een child-shell als je geruststelling nodig hebt.

Ten tweede, Hermes negeerde mijn werkdirectory en schreef game.html naar $HOME in plaats daarvan. Als je het bestand wilt waar je het hebt gestart, geef dan --no-restore-cwd of --in DIR mee. Ik heb een ronde verloren aan dat.

dsh was ondertussen klaar in 121 seconden en zijn web-UI zal dezelfde sessie teruglezen:

DeepSeek Harness web-UI met de voltooide Breakout-sessie, drie PASS-asserties, 9 stappen en 133K invoertokens op DeepSeek V4 Pro

dsh Web-UI op 127.0.0.1:3080. Let op de statusbalk: 9 stappen, cache-hit 89%, invoer 133K tokens, en de model- selector die DeepSeek V4 Pro aangeeft vanuit de configuratie van Stap 3.

--usage-file aan de Hermes-kant is echt nuttig en ondergedocumenteerd: het schrijft invoertokens, uitvoertokens, cache-leesbewerkingen, reasoning-tokens, api_calls en een geschatte kostprijs naar JSON, en het schrijft dat bestand zelfs als de run mislukt.

dsh heeft geen equivalente vlag, maar heeft die ook niet nodig. Zijn append-only sessielogboek bevat alles, met één valkuil. Het logboek op $DSH_HOME/sessions/<encoded-cwd>/session-<uuid>/session.jsonl.zstd is een multi-frame zstd-stroom, één frame per flush. zlib.zstdDecompressSync(buf) retourneert alleen het eerste frame, dus een 150KB logboek decodeert naar een paar honderd bytes en ziet er leeg uit. Splits zelf op de magische bytes:

plaintextCopy
1const MAGIC = [0x28, 0xb5, 0x2f, 0xfd], offs = [];
2for (let i = 0; i < buf.length - 4; i++)
3  if (MAGIC.every((m, j) => buf[i + j] === m)) offs.push(i);
4const text = offs
5  .map((o, k) => zlib.zstdDecompressSync(buf.subarray(o, offs[k + 1] ?? buf.length)).toString())
6  .join('');

Gebruik leeft op assistant/chunk-gebeurtenissen waar data.chunk.type === 'usage', één niveau dieper dan je zou raden (data.chunk.usage.inputTokens). Tool-aanroepen komen van assistant/message-contentblokken van het type tool-call. En request/header.data.header.config toont het model en maxTokens die daadwerkelijk over de draad gingen, waarmee je kunt bewijzen dat je Stap 3-configuratie effect had in plaats van te hopen.

Stap 6: Ronde 2, de wijzigingsaanvraag

Hetzelfde bestand, game.html ligt er al van ronde 1. Vraag nu beide om een wijziging:

plaintextCopy
1Add a falling power-up: when a brick in the top row breaks, drop a token that widens the paddle
2for 10 seconds. Keep all three selftest asserts passing and add a fourth assert for the power-up
3timer. Same file, no libraries.

Dit is de ronde die de twee ontwerpen scheidt. Hermes schrijft vaardigheden na complexe taken en houdt een drielagensgeheugen bij, dus ronde 2 is waar een vaardigheid uit ronde 1 zich ofwel terugbetaalt of niet. dsh heeft helemaal geen langetermijngeheugen, maar het heeft een append-only sessielogboek dat je kunt splitsen en opnieuw kunt afspelen vanaf halverwege in plaats van opnieuw te beginnen.

Wees eerlijk tegen jezelf over het budget voordat je hieraan begint. Mijn ronde 2 eindigde 11 tool-aanroepen in vanwege een dagelijkse uitgavenlimiet, en daarom heeft de tabel hierboven twee lege rijen in plaats van twee verzonnen rijen. Hermes' eigen dashboard laat zien waarom:

Hermes Agent-dashboard sessiepagina met de Breakout-run op 76 berichten op deepseek-v4-pro

Hermes v0.20.4 die zijn eigen sessies terugleest. De voltooide Breakout-run is 76 berichten, allemaal op deepseek-v4-pro via het Atlas-endpoint.

Stap 7: Lees de rekening

Twee getallen per run, uit het eigen logboek van de harness, nooit uit de samenvatting van de agent:

plaintextCopy
1# Hermes
2jq '{input_tokens, output_tokens, cache_read_tokens, api_calls}' hermes-r1-usage.json
3
4# dsh: aggregeer het gedecodeerde sessielogboek
5node dsh-stats.js "$DSH_HOME/sessions/<encoded-cwd>"

Controleer vervolgens tegen de gebruikerspagina van je provider. Wanneer het harness-logboek en de provider het oneens zijn, vertrouw dan de provider: dat is het getal dat je betaalt.

Voor wat het waard is, dsh's eigen statusbalk was het eens met mijn log-parser tot op afronding (133K invoertokens, 89% cache-hit tegen mijn berekende 132.600 en 88,8%). De tooling is eerlijk. De Engelse samenvattingen van de agents zijn dat niet.

Voorbij DeepSeek Harness vs Hermes: Gebruik Beide als Brein en Armen

Hier is het antwoord dat niemand in het "welke is beter"-debat biedt: je hoeft niet te kiezen.

De twee projecten falen in tegengestelde richtingen, wat ze ongewoon goede teamgenoten maakt.

Sterrenaantallen uitgelezen van beide repositories op 2026-08-21 (deepseek-ai/deepseek-harness met 176,5k sterren en 19,2k forks, NousResearch/hermes-agent met 233,6k sterren en 46,8k forks). Kijk naar de trend, niet naar de totalen: dsh stond op 144.361 sterren toen ik het op 2026-08-17 controleerde, dus het kwam er in vier dagen ruwweg 32.000 bij.

Drie manieren om ze te combineren:

• Brein en armen. Hermes op V4 Pro houdt het geheugen, de planning en de Telegram-thread vast. Het delegeert het daadwerkelijke coderen aan dsh op de goedkope laag. Eén sleutel dekt beide, dus je beheert niet twee factuurrelaties.
• Goedkope laag voor de lus, dure laag voor de beslissing. Terugkerend cron-werk draait op deepseek-v3.2 of DeepSeek V4 Flash; de moeilijke aanroep escaleert naar Pro.
• Beide headless. dsh --profile headless en Hermes -z nemen beide een prompt en geven één antwoord, dus beide passen in een shellscript of een CI-stap zonder TUI.

Eerlijke waarschuwing voor de eerlijke zwaktes, omdat een vergelijking die alleen sterke punten opsomt een advertentie is. dsh is een 0.1 ontwikkelaarspreview en zegt dat in zijn eigen UI: het zal breken tussen versies, het heeft geen geheugen, het heeft geen eigen berichtenkanaal, en het rapporteert zijn eigen tool-aanroepen te laag. Hermes is het meer volwassen project met een ruime marge, maar het is zwaarder per token met een factor 8, het bleef 13 minuten stil bij een taak die dsh in 2 minuten voltooide, en het schreef mijn uitvoerbestand naar de verkeerde directory.

Wat DeepSeek Harness vs Hermes werkelijk kost per taak

Nu de rekenkunde, met de aannames in het openbaar.

Atlas publiceert één invoertarief voor V4 Pro ($1,68 per 1M) zonder apart cache-hit-tarief op de modelpagina. Dus ik prijs elke prompttoken tegen het volledige invoertarief, inclusief gecachte reads. Dat is een conservatieve bovengrens, geen gok verkleed als meting.

Uitgewerkt voorbeeld, dsh ronde 1:

• Prompt: 14.840 vers + 117.760 gecachet = 132.600 tokens. Tegen $1,68/1M is dat $0,2228.
• Uitvoer: 5.231 tokens. Tegen $3,38/1M is dat $0,0177.
• Totaal: $0,2404 per taak.

Zelfde methode voor Hermes ronde 1: 1.111.573 prompttokens is $1,8674, plus 19.317 uitvoertokens tegen $0,0653, voor $1,9327. Hermes' eigen --usage-file schatte $0,2817 voor die run, wat impliceert dat het een gecacht invoertarief van ongeveer $0,125 per 1M aanneemt. Als je provider cache-leesbewerkingen echt zo sterk kort, dan dalen beide getallen hieronder samen en de verhouding ertussen beweegt nauwelijks.

Twee dingen springen eruit in die tabel.

De harnesskeuze is 8x waard. Hetzelfde model, dezelfde taak, hetzelfde resultaat, en de ene schil kost acht keer zoveel als de andere. Dat is geen afrondingsverschil dat je later wegoptimaliseert.

De model-laag is 12x extra waard. Dat is waarom de brein-en-armen-splitsing geen truc is: dsh op Flash kost twee cent per taak, en Hermes op Pro kost bijna twee dollar voor dezelfde Breakout-game.

En de goedkoopste optimalisatie van allemaal is nog steeds die uit Stap 3. Een dsh-route die op de standaard 262.144 blijft, doet meer compressiewerk in meer stappen om dezelfde taak te passen, en je betaalt voor elke stap.

Dat is het echte antwoord op DeepSeek Harness vs Hermes: meet je eigen schil voordat je op zoek gaat naar een goedkoper model.

DeepSeek Harness vs Hermes FAQ

Kunnen Hermes Agent en DeepSeek Harness hetzelfde model en dezelfde API-sleutel gebruiken?

Ja, en het is de enige eerlijke manier om ze te vergelijken. Beide praten met OpenAI-compatibele endpoints. dsh heeft een llm-pi-ai providerroute nodig met api: openai-completions plus baseURL; Hermes heeft provider: custom nodig plus een base_url die eindigt op /v1. Eén sleutel, beide harnessen, beide prijsklassen. Volledige configuraties staan in Stappen 3 en 4.

Is DeepSeek Harness beter dan Hermes voor coderen?

In deze test duidelijk wel: 121 seconden tegenover 780, 8 tool-aanroepen tegenover 35, en een achtste van de tokenuitgaven, terwijl beide alle drie de zelftests doorstonden. Maar "beter voor coderen" is niet "beter". Als je een geplande taak nodig hebt die elke ochtend aan Telegram rapporteert en onthoudt wat het vorige week heeft geleerd, dan heeft dsh dat niet en Hermes wel.

Zijn DeepSeek Harness en Hermes gratis en open source?

Beide hebben een MIT-licentie en zijn gratis te downloaden. Waar je voor betaalt zijn tokens, en zoals de tabel hierboven laat zien, is dat geen afrondingsfout. Het is het vermelden waard dat dsh expliciet een ontwikkelaarspreview is op 0.1 en waarschuwt voor compatibiliteitsbrekende wijzigingen in zijn eigen UI, dus pin je versie als het in de buurt van productie komt.

Waarom kost dezelfde taak meer in de ene harness?

Vier redenen, grofweg in volgorde van grootte:

• Conversatie herlezen. Gecachte prompttokens waren 88,8% van dsh's totaal en 95,5% van Hermes'. Elke extra stap stuurt alles ervoor opnieuw.
• Systeemprompt en tool-schema's. Gemeten hierboven: 10.898 vs 13.892 tokens voordat er werk gebeurt.
• Aantal stappen. 8 tool-aanroepen en 9 stappen versus 35 tool-aanroepen in 38 API-aanroepen.
• Een begrensd venster. dsh die terugvalt op 262.144 in plaats van 1.048.576 dwingt extra compressiewerk af bij lange taken.

Kan ik DeepSeek Harness en Hermes tegelijkertijd gebruiken?

Ja. Ze delen niets behalve je API-sleutel: verschillende runtimes, verschillende configuratiemappen, verschillende sessie-opslag, verschillende poorten (standaard 3080 en 9119). Het gebruikelijke patroon is Hermes als het altijd-aan-brein op de dure laag en dsh als de codeer-armen op de goedkope laag.

Werkt DeepSeek Harness alleen met DeepSeek's eigen API?

Nee, en dit is het meest voorkomende misverstand erover. Elke OpenAI-compatibele gateway werkt via api: openai-completions en een baseURL. Onthoud alleen compat.thinkingFormat: deepseek, omdat dsh het denkdialect uit de URL afleidt, en de URL van een externe gateway zegt hem helemaal niets.