DeepSeek Harness vs OpenCode : l'écart d'utilisation des tokens que la plupart des développeurs ignorent

Vous avez choisi un modèle bon marché. Vous avez fait le calcul sur la fiche technique du modèle. Puis la facture est arrivée et elle ne ressemblait pas du tout à vos calculs.

Cet écart ne vient presque jamais du modèle. Il vient du harnais (harness). Le harnais décide combien de fois votre modèle est appelé, quelle partie de la conversation est rejouée à chaque appel, la taille des schémas d'outils, et si un test qui échoue est réessayé trois fois ou douze. Même modèle, même tâche, deux harnais différents, des comptes de tokens radicalement différents.

Le 13 août 2026, DeepSeek a open sourcé son propre harnais d'agent et le débat est devenu rapidement animé. D'un côté, un dépôt vieux de deux semaines du laboratoire qui construit le modèle. De l'autre côté, OpenCode, l'agent de codage le plus étoilé sur GitHub. Les deux sont sous licence MIT. Les deux fonctionnent avec n'importe quel modèle que vous leur indiquez.

Voici donc la version honnête de la comparaison. Pas d'ambiance, pas d'étoiles. Ce que chacun fait réellement à votre utilisation de tokens, et comment le mesurer sur votre propre dépôt en environ quinze minutes.

Points clés

• DeepSeek Harness est un environnement d'exécution d'agent orienté plugins de DeepSeek AI, sous licence MIT, écrit en TypeScript, encore en version developer preview. Les modèles, outils, sessions, stockage, sandbox, boucles et même la boucle d'agent elle-même sont des plugins interchangeables.
• OpenCode est un agent de codage natif en terminal, écrit en Go, avec environ 198k étoiles GitHub, une TUI mature, le support LSP et un large catalogue de fournisseurs. C'est le choix sûr par défaut aujourd'hui.
• Le choix du harnais impacte l'utilisation de tokens bien plus que la plupart des gens ne le pensent. Dans un benchmark de 30 workflows sur DeepSeek V4 Flash, les harnais testés allaient d'environ 192 000 à 1 400 000 tokens en moyenne par tâche.
• DeepSeek Harness n'était pas dans ce benchmark. Il a été lancé deux jours après la publication, donc quiconque cite aujourd'hui des chiffres de benchmark pour Harness devine.
• Les deux sont indépendants du modèle, vous pouvez donc pointer les deux vers un même point d'accès compatible OpenAI et exécuter un test équitable identique. C'est le seul chiffre qui compte pour votre codebase.

Deux ordinateurs portables côte à côte sur un bureau ensoleillé exécutant la même tâche de codage via deux harnais d'agent différents

La seule façon équitable de comparer DeepSeek Harness vs OpenCode : un modèle, une tâche, deux terminaux.

Pourquoi DeepSeek Harness vs OpenCode est devenu le débat du mois

Le message de DeepSeek est un slogan : Agent = Modèle + Harnais. Le modèle réfléchit, le harnais lit les fichiers, exécute le terminal et appelle les outils. Pendant deux ans, tout le monde a optimisé la première moitié et traité la seconde comme de la plomberie.

La plomberie s'est avérée coûteuse.

Composio a exécuté 30 workflows multi-applications complexes via 8 harnais d'agent différents, tous utilisant le même modèle DeepSeek V4 Flash, avec une limite de 900 secondes par tâche et une notation programmatique binaire sur 240 exécutions (Composio, août 2026). Même modèle partout. Les résultats n'étaient pas proches.

Relisez la colonne des tokens. Le harnais le plus économe a utilisé environ un septième des tokens du plus gaspilleur, exécutant le modèle identique sur les mêmes tâches. La conclusion du benchmark était que les harnais « peuvent avoir autant d'importance que les modèles qu'ils exécutent ».

Maintenant, la partie que la plupart des articles omettent. DeepSeek Harness n'est pas dans ce tableau. Le benchmark a été publié le 11 août et le Harnais est arrivé le 13 août. Il n'existe pas encore de chiffre de tokens fiable de face-à-face pour DeepSeek Harness, et quiconque vous en montre un ce mois-ci l'a soit exécuté lui-même sur une tâche restreinte, soit l'a inventé. Ce que le tableau vous donne, c'est une base solide et sourcée pour OpenCode : 692 000 tokens par tâche, 46,7% de taux de réussite, 129,7 secondes médianes.

C'est le chiffre que vous essayez de battre, et le reste de cet article explique comment le tester honnêtement.

DeepSeek Harness vs OpenCode : même modèle, un point d'accès, deux environnements d'exécution

Voici la forme pratique de chaque outil avant d'exécuter quoi que ce soit.

La ligne importante est la ligne architecture. OpenCode vous donne un agent bien construit et vous permet d'étendre les bords. DeepSeek Harness vous donne un squelette et vous permet de remplacer la colonne vertébrale, y compris la boucle d'agent, qui est elle-même un plugin. C'est vraiment inhabituel, et c'est aussi pourquoi c'est encore une preview.

Les deux sont indépendants du modèle, et c'est la raison pour laquelle un test équitable est possible. Pointez les deux vers un même point d'accès compatible OpenAI servant un seul modèle, et chaque différence que vous mesurez appartient au harnais.

Pour cette démonstration, je sers DeepSeek V4 Flash depuis Atlas Cloud, car il expose un point d'accès OpenAI compatible standard que les deux harnais acceptent sans code d'adaptation, et la même clé fonctionne pour les deux exécutions. La fiche deepseek-v4-flash-0731 y est à 0,14 $ par million de tokens d'entrée et 0,28 $ par million de tokens de sortie, avec une fenêtre de contexte de 1 048 576 tokens et un maximum de sortie de 393 216, en date d'août 2026. N'importe quel fournisseur compatible OpenAI fonctionne pour ce test. L'essentiel est que les deux harnais doivent frapper le même point d'accès.

Bon à savoir avant de choisir un modèle : OpenCode publie ses propres données d'utilisation agrégées, et les modèles DeepSeek ont transféré 233 billions de tokens via celui-ci, avec V4 Flash représentant 85,5% de ce total et V4 Pro les 14,5% restants (OpenCode, août 2026). Flash est ce que l'écosystème utilise réellement.

Étape 1 : Pointer DeepSeek Harness et OpenCode vers le même modèle

Obtenez une clé API et une URL de base, puis alimentez les deux outils avec la même paire. Créez la clé dans la console Atlas Cloud et exportez-la une fois :

bashCopy
1export ATLAS_API_KEY="votre-clé-api"
2

Avant de câbler l'un ou l'autre harnais, vérifiez le point d'accès et l'identifiant exact du modèle avec un appel. Si cela ne renvoie pas de texte, rien en aval ne fonctionnera :

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": "Réponds avec le seul mot : prêt"}]
7  }'
8

Cela aide de voir le modèle répondre à la tâche réelle une fois, directement via le point d'accès, avant de le confier à un agent. Ensuite, vous savez qu'un échec provient du harnais et non du routage :

L'invite de tâche de l'article postée sur api.atlascloud.ai, à côté de la réponse réelle renvoyée par DeepSeek V4 Flash 0731 et de l'utilisation de tokens rapportée par l'appel

Un appel réel à deepseek-ai/deepseek-v4-flash-0731, le même identifiant de modèle que les deux harnais utiliseront : 148 tokens d'entrée, 6 879 tokens de sortie, dont 5 731 de raisonnement. C'est votre plancher avant qu'un harnais n'ajoute un seul schéma d'outil.

Configurez maintenant chaque côté. DeepSeek Harness lit $DSH_HOME/settings.yaml, et les fournisseurs personnalisés compatibles OpenAI se placent sous le plugin llm-pi-ai (docs DeepSeek Harness, août 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

Le champ api accepte openai-completions, openai-responses ou anthropic-messages. Utilisez openai-completions ici. Si vous préférez ne pas éditer le YAML à la main, l'interface web a Paramètres puis Modèles puis Ajouter un fournisseur personnalisé, qui écrit le même bloc et stocke la clé dans $DSH_HOME/.credentials.yaml à la place.

OpenCode lit opencode.json dans la racine de votre projet ou le répertoire de configuration global (docs OpenCode, août 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

Utilisez @ai-sdk/openai-compatible, pas @ai-sdk/openai, car ce point d'accès sert /v1/chat/completions. Définissez les valeurs limit avec les nombres réels de contexte et de sortie, car OpenCode les utilise pour décider quand résumer, et une limite incorrecte faussera gravement votre comparaison de tokens.

Étape 2 : Exécuter la tâche de benchmark dans DeepSeek Harness

Choisissez une tâche suffisamment volumineuse pour nécessiter plusieurs appels d'outils et suffisamment petite pour être notée objectivement. Multi-fichiers, plus une suite de tests qui doit réellement passer. Utilisez le même état de dépôt pour les deux exécutions, donc commitez ou stash d'abord.

Voici exactement l'invite de tâche. Collez-la textuellement dans les deux harnais :

textCopy
1Dans ce dépôt, ajoutez un middleware de limiteur de débit à seau de jetons (token-bucket) pour l'application Express dans src/server.js. Limitez chaque IP à 60 requêtes par minute. En cas de rejet, renvoyez HTTP 429 avec le corps JSON {"error":"rate_limited","retryAfter":<secondes>}. Câblez le middleware dans toutes les routes /api/*. Ajoutez des tests unitaires dans test/rate-limit.test.js couvrant trois cas : une requête sous la limite est autorisée, une requête au-dessus de la limite est bloquée avec 429, et le compteur se réinitialise après l'expiration de la fenêtre. Exécutez la suite de tests et corrigez les échecs jusqu'à ce qu'elle passe. Ne modifiez aucun fichier en dehors de src/ et test/.
2

Démarrez Harness depuis votre répertoire de projet :

bashCopy
1cd /chemin/vers/votre/depot
2npx @deepseek-ai/dsh web
3

Cela sert l'interface web sur http://127.0.0.1:3080. Sélectionnez le fournisseur atlas et le modèle deepseek-ai/deepseek-v4-flash-0731, collez la tâche, et laissez-la s'exécuter jusqu'à la fin. N'intervenez pas, ne répondez pas aux questions de clarification avec des indices. Toute aide que vous donnez à un harnais et pas à l'autre invalide la comparaison.

Lorsque cela se termine, ouvrez la vue Trajectoire. C'est l'enregistrement de la session, et c'est là que se trouvent les nombres de tokens.

Étape 3 : Répéter l'exécution dans OpenCode pour un test équitable DeepSeek Harness vs OpenCode

Réinitialisez le dépôt exactement au même état de départ. C'est l'étape où la plupart des comparaisons informelles échouent silencieusement, car le deuxième harnais démarre sur un dépôt que le premier a déjà partiellement réparé.

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

Exécutez ensuite OpenCode avec le même modèle :

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

Collez l'invite de tâche identique de l'étape 2. Utilisez l'agent build par défaut, car c'est celui qui a un accès complet aux fichiers et au shell. Encore une fois, pas d'indices, pas de corrections de cap, même traitement sans intervention.

Laissez-le terminer, puis vérifiez les deux exécutions de la même manière que vous évalueriez n'importe quelle PR :

bashCopy
1npm test
2

Une exécution qui laisse la suite en rouge n'a pas réussi, peu importe à quel point le résumé semblait confiant. Notez de manière binaire, exactement comme le fait la méthodologie Composio. Un limiteur de débit à moitié fonctionnel est un échec.

Étape 4 : Lire l'utilisation de tokens de DeepSeek Harness vs OpenCode

Maintenant, collectez les nombres. Les deux harnais suivent l'utilisation, mais ils la présentent de manière très différente, et c'est la plus grande différence au jour le jour entre eux.

DeepSeek Harness est livré avec un compteur de tokens monté par défaut. Il expose trois projections de session que vous pouvez lire directement : tokenUsage pour le total en cours, contextPressure pour savoir à quel point vous êtes proche de la fenêtre, et contextBreakdown pour savoir où sont allés les tokens. Ce dernier est le plus utile, car il vous indique si votre facture provient du prompt système, des schémas d'outils, des lectures de fichiers ou de la relecture de conversation. Le compteur utilise une heuristique fixe d'environ un token pour quatre caractères plutôt qu'un tokenizer réel, donc traitez-le comme une estimation forte, pas une facture.

Harness gère également un contexte plein différemment. Au lieu de tronquer, son moteur de compactage plie : il remplace la surface visible par le modèle par un résumé tandis que le journal complet reste dans la couche de persistance. Vous perdez des tokens du prompt, pas de l'historique de l'enregistrement.

OpenCode suit les tokens et le coût par session et les affiche dans la ligne de statut pendant que vous travaillez. La répartition dans la TUI est délibérément minimale, c'est pourquoi il existe un petit écosystème d'analyseurs externes qui lisent directement la base de données de session d'OpenCode pour décomposer l'utilisation par outil et par taux de cache. Si vous voulez une attribution par outil, vous devrez installer quelque chose.

Pour la comparaison elle-même, ne faites pas confiance au compteur de chaque outil comme mot final. Utilisez le nombre côté fournisseur, car c'est ce que vous payez réellement :

La méthode la plus propre est de créer deux clés API distinctes, une nommée harness-test et une nommée opencode-test, et d'utiliser chacune pour exactement une exécution. Ensuite, la page d'utilisation du fournisseur vous donne un face-à-face indiscutable avec zéro erreur d'estimation. Cette astuce prend deux minutes et supprime toute source de désaccord sur le compteur de qui est correct.

Utilisation de tokens de DeepSeek Harness : ce qui fait vraiment bouger la facture

Une fois que vous avez des chiffres réels, voici les leviers qui valent la peine d'être touchés. Ils s'appliquent aux deux harnais, et ils importent bien plus que celui que vous avez choisi.

La relecture de conversation est généralement la plus grosse ligne. Les agents renvoient la conversation croissante à chaque étape. Une tâche de 40 étapes ne coûte pas 40 prompts, elle coûte quelque chose de proche de la somme de 40 prompts de plus en plus longs. C'est pourquoi l'écart du benchmark allait de 192 000 à 1 400 000 tokens pour un travail identique. Les harnais qui résument de manière agressive se situent en bas de cette fourchette.

Les hits de cache sont l'optimisation la moins chère disponible. Les hits de cache DeepSeek V4 Flash sont facturés environ 0,0028 $ par million de tokens contre 0,14 $ par million en cas d'échec, soit environ 98 % moins cher. La mise en cache ne fonctionne que lorsque le préfixe de la requête est identique octet par octet, ce qui est exactement la raison pour laquelle DeepSeek Harness applique une interpolation stricte {{variable}} avec une sémantique d'échec bruyant et maintient un en-tête de requête stable. Un harnais qui mélange votre prompt système entre les appels transforme silencieusement chaque hit en échec.

Les schémas d'outils voyagent sur chaque appel. Vingt serveurs MCP connectés signifient vingt ensembles de schémas dans le prompt, pour toujours, que la tâche les touche ou non. Déconnectez ce dont cette tâche n'a pas besoin avant de benchmarker, ou vous mesurez votre configuration MCP plutôt que votre harnais.

Les résultats d'outils surdimensionnés empoisonnent le contexte. Un seul cat d'un fichier de 3000 lignes, ou un testeur verbeux qui vide des piles d'appels complètes, reste dans la conversation pour le reste de l'exécution. Harness dispose d'un compagnon optionnel d'élagage des résultats qui réécrit les résultats d'outils surdimensionnés avant de les résumer. Cela vaut la peine de l'activer.

Les tentatives sont invisibles jusqu'à ce que vous comptiez les appels. Un harnais qui réessaie un test échoué trois fois dépense le triple. Comparez la colonne du nombre d'appels, pas seulement le total de tokens, ou vous diagnostiquerez mal une boucle de tentatives comme un modèle coûteux.

En termes de coût, l'arithmétique est simple une fois que vous avez un nombre de tokens. Au tarif Atlas Cloud pour DeepSeek V4 Flash, une tâche de 692 000 tokens pondérée vers l'entrée se situe dans les quelques centimes. C'est la bonne nouvelle de toute cette catégorie : le modèle est suffisamment bon marché pour que le gaspillage du harnais soit un problème d'efficacité plutôt qu'une urgence budgétaire. Cela ne devient un nombre réel que lorsque vous multipliez par une équipe, fonctionnant toute la journée, tous les jours. Parcourez le catalogue complet de modèles si vous voulez exécuter le même test avec un deuxième modèle et séparer les effets du modèle des effets du harnais.

Une mise en garde qui devrait façonner votre décision plus que n'importe quel nombre de tokens : DeepSeek Harness est explicitement en developer preview et son propre README prévient en majuscules qu'il y aura des changements cassants de compatibilité. C'est une bonne chose à benchmarker et une chose risquée à normaliser pour une équipe ce mois-ci. OpenCode est le choix ennuyeux, et ennuyeux est une fonctionnalité quand il fonctionne sur votre dépôt de production.

Questions fréquentes

DeepSeek Harness est-il meilleur qu'OpenCode ?

Pas encore, pour la plupart des gens. OpenCode est mature, natif en terminal, a environ 198k étoiles et un large catalogue de fournisseurs, et il fonctionne aujourd'hui. DeepSeek Harness a deux semaines, est en developer preview, et prévient des changements cassants. Harness est plus intéressant architecturalement, car chaque composant, y compris la boucle d'agent, est un plugin remplaçable. Si vous voulez réécrire les internes de l'agent, Harness est conçu pour cela. Si vous voulez livrer du code cette semaine, OpenCode.

DeepSeek Harness fonctionne-t-il uniquement avec les modèles DeepSeek ?

Non. Il est indépendant du modèle. Il est livré avec des fournisseurs de catalogue pour DeepSeek, Anthropic, OpenAI, Bedrock, Vertex, Azure et Codex, et vous pouvez ajouter n'importe quel fournisseur personnalisé qui parle openai-completions, openai-responses ou anthropic-messages en ajoutant un bloc dans $DSH_HOME/settings.yaml. La configuration de l'étape 1 le pointe vers un point d'accès tiers compatible OpenAI sans code d'adaptation.

Comment vérifier l'utilisation de tokens de DeepSeek Harness ?

Utilisez le compteur de tokens intégré, qui est monté par défaut et expose les projections tokenUsage, contextPressure et contextBreakdown, visibles dans la vue Trajectoire. Notez qu'il estime avec une heuristique fixe d'environ un token pour quatre caractères plutôt qu'en exécutant un tokenizer réel. Pour la précision de facturation, lisez plutôt le tableau de bord d'utilisation de votre fournisseur, idéalement avec une clé API dédiée par exécution. Des plugins communautaires comme les tableaux de bord d'utilisation de tokens ajoutent des enregistrements persistants par session par-dessus.

Quel harnais utilise moins de tokens, DeepSeek Harness ou OpenCode ?

Il n'y a pas encore de face-à-face publié. Le benchmark de 8 harnais sur DeepSeek V4 Flash a mesuré OpenCode à 692 000 tokens moyens par tâche, mais il a été exécuté deux jours avant la sortie de DeepSeek Harness, donc Harness n'était pas inclus. Quiconque cite un chiffre de Harness provenant de ce benchmark cite quelque chose qui n'existe pas. Exécutez le test des étapes 2 à 4 sur votre propre dépôt, car l'utilisation de tokens dépend fortement de la taille de votre codebase, de votre configuration MCP et de la forme de votre tâche.

Puis-je exécuter DeepSeek Harness et OpenCode avec la même clé API ?

Oui, et pour un test informel, cela convient. Pour une mesure propre, utilisez deux clés distinctes, une par harnais. Ensuite, le tableau de bord d'utilisation de votre fournisseur attribue automatiquement chaque token à la bonne exécution et vous n'avez jamais à concilier deux estimateurs internes différents avec une seule facture.

Quelle est la différence entre un agent et un harnais ?

Le cadrage de DeepSeek est : Agent = Modèle + Harnais. Le modèle effectue le raisonnement. Le harnais est tout ce qui le connecte à la réalité : lire et écrire des fichiers, exécuter des commandes shell, appeler des outils, gérer les sessions, gérer les approbations et piloter la boucle qui décide quoi faire ensuite. Même modèle plus un harnais différent vous donne un agent mesurablement différent, ce qui est le but même de cette comparaison.