DeepSeek V4.1 Flash dans OpenCode : configuration, coût et le réglage d’effort dont personne ne parle

DeepSeek V4.1 Flash est présent dans OpenCode Go depuis le 10 septembre, et le multiplicateur qu’OpenCode y a associé a une date de fin publiée : le 20 septembre. Cela fait quatre jours à partir d’aujourd’hui. Le plus intéressant n’est pas l’échéance — c’est que le réglage qui détermine si ce modèle est agréable pour coder est absent de tous les guides de configuration de la première page de résultats, et dans au moins deux harnais, il est silencieusement abandonné. Voici un guide pour pointer un agent de codage vers DeepSeek V4.1 Flash : les identifiants exacts du modèle, les trois intégrations vérifiées aujourd’hui, le contrôle de l’effort de raisonnement rapporté par la communauté, et le mode de défaillance de la sur-réflexion avec les mesures d’atténuation qui fonctionnent réellement.

Ce vers quoi vous pointez réellement votre agent

DeepSeek V4.1 Flash est sorti le 10 septembre 2026 — la note de version figurant dans la documentation API de DeepSeek elle-même est datée de ce jour-là, et il s'agit du plus petit modèle de la nouvelle famille d'architectures du fournisseur. DeepSeek annonce une architecture de base de type mélange d'experts à 552 milliards de paramètres, construite sur ce qu'il appelle une conception Causal Encoder–Decoder, activant environ 8 milliards de paramètres par jeton pendant le préremplissage et 16 milliards pendant le décodage. Il prend en entrée du texte et des images et renvoie du texte, offre une fenêtre de contexte allant jusqu'à un million de jetons et générera jusqu'à 384 000 jetons en une seule réponse — les plafonds de contexte et de sortie proviennent tous deux de la propre page de modèle d'OrcaRouter consacrée à ce modèle, qui indique respectivement 1 048 576 et 384 000.

Les benchmarks du fournisseur, issus du graphique de la page de publication de DeepSeek et donc déclarés par le fournisseur et non audités : 30,0 sur Terminal-Bench 3.0, 74,2 sur DeepSWE v1.1, 88,1 sur CyberGym, 54,8 sur Automation-Bench et 90,9 sur GPQA Diamond. Les scores indépendants sont plus rares, mais ils existent — Artificial Analysis, consulté directement aujourd'hui, place DeepSeek V4.1 Flash à 40 sur son Intelligence Index, classé 6e sur 113 dans sa classe de comparaison. Une ligne de cette même page compte plus pour un lecteur agent de codage que le classement ne le fait : Artificial Analysis qualifie le modèle de très verbeux, ayant consommé 250 M de tokens de sortie pour terminer son évaluation Intelligence Index, contre une médiane de 140 M. Nous y reviendrons.

Deux précisions de nommage font gagner un temps réel de débogage. L'identifiant canonique du modèle d'API de DeepSeek est désormais code>deepseek-flash/code>. Les anciennes chaînes code>deepseek-v4-flash/code> et code>deepseek-v4-flash-vision-exp/code> sont toujours acceptées, mais les modèles derrière elles ont été retirés et les requêtes sont servies par V4.1 Flash au prix de Flash. Par ailleurs, DeepSeek V4 Pro n'a pas disparu : la documentation de DeepSeek indique que le service d'API V4 Pro continue après le 2026-09-14 avec une facturation inchangée. Si l'on vous a dit que le modèle phare avait été désactivé, ce n'est pas ce que disent les propres documents du fournisseur.

OpenCode : deux voies d’accès, et l’identifiant à saisir réellement

Il existe deux façons de mettre DeepSeek V4.1 Flash derrière OpenCode, et elles ont des logiques économiques différentes.

La formule d'abonnement est OpenCode Go, un forfait à 10 $/mois qu'OpenCode décrit comme un ensemble sélectionné de modèles de codage ouverts qu'il a testés et évalués. La configuration se fait en quatre étapes et il n'y a aucun fichier de configuration à modifier manuellement : connectez-vous à OpenCode Zen, abonnez-vous à Go, copiez la clé API, puis exécutez code>/connect/code> dans l'interface TUI, choisissez OpenCode Go et collez la clé. Ensuite, code>/models/code> répertorie ce qui est disponible. Les références de modèle dans la configuration prennent la forme code>opencode-go/<model-id>/code>.

Quel identifiant de modèle ? Les deux. La liste de modèles propre à la passerelle Go, récupérée aujourd'hui depuis code>https://opencode.ai/zen/go/v1/models/code>, renvoie code>deepseek-flash/code> et code>deepseek-v4.1-flash/code> comme deux entrées distinctes, aux côtés de l'ancien code>deepseek-v4-flash/code> et code>deepseek-v4-pro/code>. L'un comme l'autre des deux premiers correspond au modèle que vous voulez ; code>deepseek-flash/code> est le nom canonique et le choix le plus sûr pour tout ce que vous comptez garder en fonctionnement.

La route directe ignore complètement l'abonnement : exécutez code>/connect/code>, recherchez DeepSeek et collez une clé de plateforme DeepSeek. Vous êtes ensuite facturé par DeepSeek au prix catalogue plutôt que de puiser dans une allocation Go. DeepSeek publie son prix catalogue en heures creuses à 0,15 $ par million de jetons d'entrée et 0,60 $ par million de jetons de sortie, avec des lectures mises en cache à 0,003 $ par million — et exactement le double de ces tarifs pendant les heures pleines. Tant la documentation OpenCode Go que la page de modèle d'OrcaRouter, consultées aujourd'hui, s'accordent sur ces chiffres.

Ce qu'OpenCode Go ajoute, c'est la structure des quotas, et ici les chiffres méritent d'être lus attentivement, car c'est ce qui fait toute l'importance de la date limite. La documentation d'OpenCode elle-même répertorie DeepSeek V4.1 Flash avec une limite mensuelle de 15 $, actuellement multipliée par 4 pour atteindre 60 $ dans le cadre d'une promotion qu'OpenCode annonce comme « se terminant le 20 septembre ». Les estimations du nombre de requêtes sont publiées en deux colonnes : 6 500 par tranche de 5 heures / 16 250 par semaine / 32 500 par mois au tarif standard, ou 26 000 / 65 000 / 130 000 avec le multiplicateur de 4 appliqué. La structure des quotas est la même pour tous les modèles — la limite de 5 heures correspond à 20 % du chiffre mensuel, la limite hebdomadaire à 50 %, et la limite mensuelle représente le total.

Ce sont les chiffres publiés par OpenCode, lus aujourd'hui dans sa documentation Go. C'est à eux qu'il revient de mettre fin à la promotion, et celle-ci porte une date.

Command Code : toujours en direct, et un rapport de bug à connaître

Le catalogue propre de Command Code liste encore le modèle à ce jour, sous l'id code>deepseek-v4-1-flash/code>, avec une fenêtre de contexte de 1 M de tokens et la même économie de pass-through : 0,15 $ / 0,60 $ hors pointe, 0,30 $ / 1,20 $ en pointe, 0,003 $ la lecture en cache. La concordance des prix entre deux harnais indépendants n'est pas une coïncidence — les deux répercutent le prix catalogue de DeepSeek plutôt que de fixer le leur.

La mécanique est simple. Installez avec code>npm i -g command-code/code>, exécutez-le depuis le répertoire de votre projet, authentifiez-vous avec code>/login/code>, et utilisez code>/connect/code> si vous souhaitez utiliser votre propre clé de fournisseur. code>/model <id>/code> applique directement un changement de modèle, tandis qu'un simple code>/model/code> ouvre un sélecteur, et code>/effort/code> définit l'effort de raisonnement pour le modèle actuel — l'option qui compte le plus ici.

Un rapport de bug communautaire vaut la peine d'être gardé en tête avant de déboguer la mauvaise couche. Une issue ouverte contre une couche de routage tierce décrit un cache de relecture du raisonnement qui ne s'active jamais pour code>command-code/deepseek-v4.1-flash/code> comme identifiant, car le motif sur lequel la couche de routage effectue la correspondance attend un segment code>v4./code> ou code>v4-/code>, alors que la chaîne est code>v4.1/code>. Le symptôme signalé correspond à des erreurs 400 en amont indiquant que le contenu de raisonnement produit en mode réflexion doit être renvoyé à l'API. Il s'agit d'un rapport de bug communautaire concernant un matcher côté client, et non de consignes du fournisseur, ni d'un problème lié au modèle — mais c'est exactement le genre de chose qui ressemble à une défaillance du modèle à 2 heures du matin.

Claude Code, Codex et les clients qu'OpenCode lui-même a validés

OpenCode Go n'est pas exclusif à OpenCode, et leur documentation le dit explicitement : il est conçu pour OpenCode et d'autres agents de codage qui produisent des schémas de requêtes similaires, avec une liste publiée de clients validés pour fonctionner. Cette liste mentionne actuellement Hermes, Claude Code, Codex, ZCode et Pi — et pour Claude Code, la note indique qu'il « reconnaît son en-tête de session natif. Aucun wrapper d'en-tête personnalisé n'est nécessaire. » Deux exigences l'accompagnent : identifier votre client avec son propre user agent plutôt qu'un nom de SDK générique, et envoyer un identifiant de session stable dans l'en-tête code>x-opencode-session/code> à chaque conversation, ce qui permet à leur routage et à leur mise en cache des prompts de fonctionner. Pour Hermes, la version validée compte — le correctif d'en-tête a été fusionné après la v0.21.0, donc cette version seule ne l'inclut pas.

Il existe également une route sans aucun abonnement associé, en utilisant directement le point de terminaison de DeepSeek compatible avec Anthropic. Définissez code>ANTHROPIC_BASE_URL/code> à code>https://api.deepseek.com/anthropic/code>, code>ANTHROPIC_AUTH_TOKEN/code> à votre clé DeepSeek, et pointez les variables de modèle vers le modèle. Les noms de modèles Claude sont remappés à l'entrée : tout ce qui commence par code>claude-opus/code> va vers DeepSeek V4 Pro et est facturé au prix du V4 Pro, tandis que code>claude-sonnet/code> et code>claude-haiku/code> : les noms vont vers le modèle Flash. Le code>[1m]/code> est un suffixe sur la chaîne de modèle qui demande la variante de contexte d'un million de tokens. Le guide de DeepSeek pour cette configuration définit aussi code>CLAUDE_CODE_EFFORT_LEVEL=max/code> et fixe la fenêtre d'auto-compactage à 786432 tokens.

Cette dernière variable est là où réside un correctif communautaire. Un proxy de contournement existe parce que les versions récentes de Claude Code envoient code>thinking: {"type": "disabled"}/code> lors des requêtes de sous-agents tandis que code>CLAUDE_CODE_EFFORT_LEVEL=max/code> ajoute un paramètre d’effort de raisonnement, et le point de terminaison au format Anthropic de DeepSeek rejette cette association avec un message indiquant que les options de réflexion ne peuvent pas être désactivées lorsque l’effort de raisonnement est défini. Le contournement signalé est limité — supprimer le paramètre d’effort uniquement des requêtes de sous-agents, en laissant l’agent principal intact. Considérez-le comme une observation communautaire concernant une incompatibilité de contrat client/serveur, et attendez-vous à ce que la frontière exacte de version se déplace.

Le cadran d’effort : 1–100, et pourquoi « faible » signifie 50

Tout dans cette section relève d’une observation de la communauté plutôt que de recommandations du fournisseur. DeepSeek ne publie pas de correspondance entre préréglages et numéros que nous pourrions vérifier, et les numéros ci-dessous proviennent de retours de praticiens et de documentation de bancs d’essai tiers. Ils sont suffisamment cohérents d’une source à l’autre pour être utiles, et suffisamment non confirmés pour que vous deviez les tester sur votre propre travail.

DeepSeek V4.1 Flash est entraîné avec un scalaire continu d’effort de raisonnement allant de 1 à 100. Il ne s’agit pas d’un plafond de tokens — il détermine où le modèle se situe sur une courbe apprise par le processus d’entraînement, où un effort plus faible exerce davantage de pression pour être concis et où un effort plus élevé rend le raisonnement supplémentaire moins coûteux. Trois préréglages publics correspondent à cette échelle :

• Faible — 50, le chemin le plus court, et le préréglage qui vaut à ce contrôle sa réputation de bon marché.

• Élevé — 75, et le niveau que la plupart des sources communautaires décrivent comme le plafond raisonnable pour le travail d’agent.

• Max — 100, où la pénalité sur la longueur du raisonnement est entièrement supprimée.

Ce que le réglage apporte est réel, mais connaît des rendements fortement décroissants. Une campagne d'évaluation communautaire a rapporté que faire passer l'effort de 25 à 100 a fait grimper Terminal-Bench 2.1 de 82,4 à 90,6, tout en multipliant globalement par environ 2,5 le nombre de tokens de sortie. Les rapports convergent vers un effort compris entre 60 et 80, qui capte l'essentiel de la précision disponible pour moins de la moitié du budget de tokens, le maximum ajoutant encore un facteur 1,6–1,8 aux trajectoires d'agent pour un gain marginal.

La valeur par défaut est la partie sur laquelle personne ne s'accorde. Certaines documentations de harness et certains retours de praticiens affirment qu'un effort non défini se résout en high ; d'autres décrivent la valeur par défaut du serveur comme simplement inconnue. Ce qui est documenté, et non débattu, c'est que deux intégrations de harness se sont révélées ne pas envoyer le paramètre du tout — le profil de fournisseur OpenCode Go et un profil DeepSeek natif ont tous deux omis d'émettre code>reasoning_effort/code> pour le slug code>deepseek-flash/code>, car leur garde de correspondance attendait un code>deepseek-v…/code> comme préfixe que l'id canonique ne possède pas. Dans les deux cas, le réglage choisi par l'utilisateur a été silencieusement remplacé par la valeur par défaut du fournisseur. Si votre client affiche un contrôle d'effort, ce n'est pas la preuve qu'il est réellement transmis. Consignez un corps de requête et regardez.

Encore une bizarrerie issue des mêmes rapports : le point de terminaison OpenCode Go accepte code>low/code>, code>medium/code>, code>high/code> et code>max/code>, mais rejette un effort sous forme d'entier — une valeur de 80 a été signalée comme renvoyant HTTP 400. Le réglage 1–100 existe dans le modèle, mais il n'est pas exposé partout sous forme de nombre brut, donc « régler l'effort sur 65 » peut ne pas être exprimable dans votre client.

Le mode de défaillance de la surréflexion, et ce qui le corrige réellement

C’est le mode de défaillance qui détermine si vous gardez le modèle dans votre boucle. Des rapports de la communauté décrivent DeepSeek V4.1 Flash qui continue à raisonner alors que le travail est terminé : il rediscute un point auquel il a déjà répondu correctement, raconte la correction de ses propres hypothèses erronées et produit de longues chaînes de raisonnement à faible densité d’information. Un praticien a signalé une sortie de raisonnement qui a continué pendant plus d’une heure dans une session CLI de codage. Un autre a signalé ne pas pouvoir lui faire terminer du tout une longue exécution de benchmark.

Une note de provenance sur ce deuxième rapport, parce que c'est le genre d'affirmation qui se fait blanchir. Il provient d'un fil communautaire sur l'exécution fiable du modèle, et Reddit bloque notre outil de récupération, donc nous n'avons pas pu lire le fil directement — nous relayons le rapport plutôt que de citer une page que nous avons ouverte. Ce que nous avons pu vérifier de manière indépendante, c'est la forme du problème, et là, les preuves externes sont inhabituellement nettes : Artificial Analysis, sur sa propre page, signale que le modèle est très verbeux, consommant 250 M de tokens de sortie pour terminer une exécution que son modèle de comparaison médian termine en 140 M. Cela représente environ 1,8×, mesuré par un tiers, sur un ensemble de tâches fixe. Les signalements du forum et la mesure indépendante décrivent le même comportement.

Les mesures d’atténuation qui ressortent de ces rapports, toutes issues de la communauté :

• Figez l’effort à high ou en dessous et refusez qu’il puisse augmenter par effet de cliquet. Le correctif le plus explicite observé en conditions réelles est un plugin de routage écrit spécialement pour stopper l’escalade d’effort : la profondeur de tour ne contribue en rien au score d’escalade, seuls un résultat d’outil en échec ou une nouvelle tentative identique comptent, l’escalade est plafonnée, et max est en opt-in et rétrogradé par défaut. Si votre harness permet à un agent d’augmenter son propre effort à mesure qu’une exécution s’allonge, c’est le mécanisme à désactiver.

• N'exécutez pas max par défaut. Plusieurs praticiens signalent que max tourne en rond au lieu de converger sur des tâches de routine, et que le retour à high résout le problème.

• Plafonnez code>max_tokens/code> sur les chemins interactifs. Un plafond de sortie de 384 000 tokens est une limite, pas un objectif, et une boucle qui ne se termine pas coûte cher à ce plafond.

• Vérifiez que le paramètre est bien envoyé. Étant donné que deux harnais se sont avérés le supprimer silencieusement, « je l'ai réglé sur high » et « high est bien arrivé à l'API » sont deux affirmations différentes.

• Le harnais compte plus qu’on ne s’y attendrait. Les praticiens qui exécutent les mêmes poids rapportent un comportement nettement différent d’un shell à l’autre — le même modèle qui se contredit et noie le signal dans un harnais ne suscite aucune de ces critiques dans un autre. Il s’agit d’une observation de la communauté sur le comportement du harnais, non d’une affirmation d’un fournisseur sur le modèle, mais c’est le conseil le plus répété dans les rapports.

Ce que coûte réellement une boucle de codage à ces tarifs

Le prix catalogue de DeepSeek est, hors heures de pointe, de 0,15 $ par million de tokens d’entrée et de 0,60 $ par million de tokens de sortie — la sortie coûte quatre fois l’entrée, ce qu’il faut assimiler en premier au sujet d’un agent qui génère du raisonnement autant que du code.

Prenons un tour d’agent réaliste : 60 000 tokens de contexte (prompt système, schémas d’outils, un extrait de dépôt, historique de conversation) en entrée, et 3 000 tokens de raisonnement plus un patch en sortie. Cela fait 60 000 × 0,15 $/1 M = 0,009 $ en entrée, plus 3 000 × 0,60 $/1 M = 0,0018 $ en sortie, soit environ 1,1 cent par tour. Deux cents tours de ce type dans une journée de travail coûtent environ 2,16 $, soit près de 47 $ sur un mois de jours ouvrés au tarif hors pointe. Voilà le calcul qui fait paraître généreuse une allocation mensuelle de 15 $ avec une promo de 4× en plus — et le calcul qui fait de la verbosité la chose à surveiller.

Car voici le levier qui se cache dans ce chiffre d’Artificial Analysis. Que le modèle utilise 1,8× les tokens de sortie médians sur un ensemble de tâches fixe signifie qu’une boucle limitée par la sortie coûte 1,8× ce que le prix des tokens seul laisse penser. Et le réglage d’effort est précisément la commande pour cela. Les retours de la communauté estiment le passage de max à high à environ une réduction de moitié des tokens de sortie — une variation bien plus grande que tout ce que le calendrier heures pleines/heures creuses pourra vous imposer. Le réglage d’effort est le levier principal ; le calendrier est le levier gratuit.

Ce qu'il vaut la peine de savoir avant de planifier quoi que ce soit : les heures de pointe sont 01:00–04:00 et 06:00–10:00 UTC, du lundi au vendredi, et tout le reste, y compris les week-ends, est en heures creuses. Une équipe européenne travaillant de 09:00 à 18:00 CET n'est jamais concernée par les heures de pointe. Une équipe à Pékin travaillant aux mêmes heures locales tombe sur les heures de pointe de 09:00 à 12:00 et de 14:00 à 18:00 — sept de ses neuf heures de travail à tarif double. Même modèle, même code, facture doublée : tout dépend uniquement du fuseau horaire.

L'autre économie gratuite est le tarif de lecture en cache, 0,003 $ par million contre 0,15 $ pour une entrée fraîche — un cinquantième. L'invite d'un agent de codage est en grande partie un préfixe stable : les instructions système, les définitions d'outils, les parties du dépôt qui ne changent pas. Gardez le matériel stable au début et laissez le contenu variable le suivre, et le cache côté fournisseur fait le reste. Que l'entrée en cache à tarif réduit s'applique, et à quelles conditions, est déterminé par DeepSeek plutôt que par le client, alors vérifiez-le dans la documentation actuelle avant de bâtir un budget dessus — notre propre page modèle pour code>deepseek/deepseek-v4.1-flash/code> dit la même chose, à savoir que le tarif d'entrée en cache suit les conditions du fournisseur.

Si vous préférez ne pas ajouter un second abonnement pour évaluer le modèle, le même identifiant est disponible via un seul point de terminaison compatible OpenAI en amont de tout notre catalogue, au tarif du fournisseur avec 0 % de marge — ainsi, un changement de prix côté DeepSeek est répercuté ici le jour même plutôt qu'à la prochaine réévaluation tarifaire. Cela compte surtout pour exactement la situation décrite dans cet article : un modèle ayant une tendance documentée à continuer, sur une trajectoire que vous n'avez pas fini d'évaluer. Une chaîne de repli signifie qu'un tour qui se passe mal retombe sur un autre modèle avant que la réponse ne commence, au lieu de faire échouer la requête.

552B, 748B ou 763B — la question de la taille est vraiment ouverte

Ne répétez pas un nombre de paramètres pour ce modèle comme s'il était établi, car trois chiffres différents circulent et aucun n'est simplement faux.

La fiche de modèle de DeepSeek elle-même décrit un modèle à « 552B de paramètres de backbone », et il s’agit du chiffre rapporté par le fournisseur — c’est aussi le nombre indiqué dans le panneau des spécifications sur notre propre page de modèle. La même fiche répertorie séparément un module « Engram conditional memory » de 196B de paramètres, « sparsely accessed via token-based lookup ». Additionnez les deux et vous obtenez 748B, ce qui correspond au calcul sur lequel l’analyse de la communauté a abouti dans les heures suivant la sortie. Et les métadonnées de fichier du même dépôt de modèle indiquent une taille de modèle de 763B de paramètres, ce qui constitue là encore un troisième chiffre.

Le désaccord apparent relève d’une question de définition plutôt que d’une contradiction. Les paramètres Engram récupérés par consultation coûtent de la mémoire, mais presque aucun calcul arithmétique par token, tandis que les paramètres calculés du backbone coûtent du temps à chaque token — c’est précisément pourquoi le fournisseur les indique séparément et pourquoi comparer les chiffres phares de deux modèles aux architectures différentes ne vous apprend que très peu.

Ce qui n'est pas sérieusement contesté, c'est le nombre de paramètres actifs : environ 8 Md par token pendant le préfill et 16 Md pendant le décodage, soit le chiffre qui détermine réellement le coût d'inférence. Les poids sont ouverts sous licence MIT si vous voulez vérifier tout cela vous-même. Considérez 552 Md comme déclaré par le fournisseur, 748 Md comme un total communautaire crédible, et toute affirmation selon laquelle la question de la taille est close comme prématurée.

Que faire avant le 20

Si vous comptez essayer DeepSeek V4.1 Flash dans un agent de codage, l’ordre qui fait perdre le moins de temps est : choisissez d’abord le harnais, puis fixez l’effort, puis mesurez.

Sur le harnais, le résumé honnête de la vérification d'aujourd'hui est que les trois routes fonctionnent et qu'elles diffèrent par ce qu'elles exigent de vous. OpenCode Go est un abonnement à 10 $/mois avec un multiplicateur promotionnel qui expire le 20 septembre, et la configuration consiste en code>/connect/code> plus code>/models/code>, sans aucun fichier à modifier. Command Code liste le modèle en direct dans son propre catalogue, bascule avec code>/model <id>/code>, et expose l'effort comme une commande à part entière. Claude Code y accède soit via le chemin des clients validés d'OpenCode Go — où il n'a besoin d'aucun enveloppe d'en-tête personnalisée — soit directement contre le point de terminaison au format Anthropic de DeepSeek, où le conflit d'effort des sous-agents est la difficulté connue.

Pour l’effort, définissez-le explicitement et réglez-le plutôt bas : high, ou la valeur par défaut du modèle si c’est high qui en résulte, et pas max. Ensuite, confirmez qu’il a bien quitté votre machine, car on a constaté que deux harnais le supprimaient.

En matière de mesure, surveillez les tokens de sortie plutôt que le temps d'horloge. La verbosité est le coût, le réglage de l'effort est le levier de contrôle, et l'horaire de pointe est un accident de fuseau horaire que vous pouvez éviter gratuitement.

Et pour les affirmations de taille que l’on vous citera cette semaine — 552B, 748B, 763B — la réponse utile est que le fournisseur déclare son backbone, que la communauté ajoute le module de mémoire et que les métadonnées du dépôt disent encore autre chose. Quiconque présente l’un de ces chiffres comme la réponse définitive a choisi un chiffre plutôt que d’en vérifier un.