Le coût par tâche, pas le coût par token : l'économie unitaire des workloads LLM de pointe

Résumé

Le coût par token n'est pas la bonne unité pour les workloads agentiques et de production. La bonne unité, c'est le coût attendu par tâche accomplie, plus le coût de correction des sorties erronées qui échappent aux contrôles automatisés :

$$\mathbb{E}[\text{coût par tâche résolue}] = \frac{C_{\text{attempt}}}{p_{\text{success}}}$$

Sur le coût brut en tokens par tâche à la mi-2026, le tout dernier modèle de pointe d'OpenAI est souvent l'option la moins chère. Artificial Analysis a mesuré GPT-5.6 Sol à 1,04 $ par tâche de l'Intelligence Index, contre 2,03 $ pour Claude Opus 5 et 2,75 $ pour Claude Fable 5. OpenAI a comblé l'écart d'efficacité en tokens.

Anthropic l'emporte dès que la fiabilité entre au dénominateur. Sur tau-bench, Claude Opus 4.8 a conservé une part bien plus élevée de son score en tentative unique sur des exécutions répétées et a violé les règles plus de deux fois moins souvent que GPT-5.5. Dans les boucles autonomes à enjeux élevés, cette régularité réduit les relances et les corrections humaines — et c'est là que se joue l'essentiel du coût réel.

Principaux enseignements

Les prix catalogue des modèles phares ont convergé. Claude Opus 5 coûte 5 $ en entrée / 25 $ en sortie par million de tokens. GPT-5.6 Sol coûte 5 $ / 30 $. Anthropic est désormais moins cher sur le prix catalogue en sortie, et non plus cher. Le vieux discours Claude coûte plus cher au token est largement obsolète au niveau des modèles de pointe.

Les décomptes de tokens ne sont pas comparables d'un fournisseur à l'autre. Le tokenizer d'Anthropic produit, depuis Opus 4.7, environ 30 % de tokens en plus pour un même texte, et Opus 4.8 et Opus 5 affichent environ 1,88 token par mot anglais contre environ 1,17 pour l'encodage o200k de GPT-5. À tarif égal par million de tokens, chaque dollar achète moins de mots de contexte Claude. Cela fausse les comparaisons naïves au token au détriment d'Anthropic.

Les tokens de raisonnement sont facturés comme des tokens de sortie sur les deux plateformes, et OpenAI les masque tandis qu'Anthropic peut les restituer. Une réponse visible de 500 tokens peut embarquer des milliers de tokens de raisonnement facturés.

Le taux de réussite au dénominateur domine. Un modèle 10 % plus cher par tentative mais nettement plus régulier peut revenir bien moins cher par tâche correcte et conforme, une fois comptés les relances et les corrections humaines.

Le prompt caching change l'arithmétique des sessions longues, des deux côtés. Les lectures de cache coûtent 10 % du prix d'entrée chez Anthropic comme sur les modèles actuels d'OpenAI.

En détail

Le problème : le prix au token ne mesure pas ce qui compte

Les équipes choisissent leurs modèles selon les capacités, la disponibilité et l'adéquation fournisseur. Mais quand elles comparent les coûts, elles parcourent une grille tarifaire : 5 $ contre 10 $ par million de tokens, et s'arrêtent là. Cette comparaison est à peu près inutile pour tout ce qui est agentique.

Une tâche agentique n'est pas un seul appel d'API. C'est une boucle.

Planifier, appeler un outil, lire le résultat, décider, modifier, vérifier, recommencer. L'analyse de Vantage sur les sessions de codage agentiques modélise une session représentative de 50 tours à environ 1 million de tokens en entrée et 40 000 en sortie, soit un ratio entrée/sortie proche de 25 pour 1, l'entrée représentant environ 85 % du coût total, parce que le modèle relit à chaque tour un contexte qui ne cesse de grossir. L'analyse de Gartner de mars 2026 a établi que les workflows agentiques consomment 5 à 30 fois plus de tokens par tâche qu'une simple requête de chatbot, et Will Sommer, son senior director analyst, a formulé le risque sans détour : les chief product officers "ne doivent pas confondre la déflation des tokens de commodité avec la démocratisation du raisonnement de pointe". Bai et al. (arXiv:2604.22750), un préprint analysant huit trajectoires de LLM de pointe sur SWE-bench Verified, cosigné par des chercheurs dont Erik Brynjolfsson (Stanford) et Alex Pentland (MIT), a constaté que les tâches de codage agentiques consomment jusqu'à 1 000 fois plus de tokens que le raisonnement sur code et le chat sur code, avec une variance allant jusqu'à 30x d'une exécution à l'autre et des tokens d'entrée qui dominent la facture.

La plupart des ingénieurs n'ont jamais vu ce que coûte réellement une trajectoire d'agent. L'équipe de Bai et al. a publié ses données brutes sur longjubai.github.io/agent_token_consumption, avec un jeu de pronostics : vous lisez une vraie tâche de codage, prédisez la facture en tokens, puis découvrez ce que huit modèles de pointe ont réellement dépensé. Jouez trois manches avant de faire confiance à la moindre estimation de coût, y compris la vôtre. Les modèles eux-mêmes sous-estiment leur consommation, et vous aussi. C'est précisément cet écart entre dépense prévue et dépense réelle qui justifie de mesurer le coût par tâche plutôt que de le prévoir.

Deux constats en découlent. D'abord, le nombre de tokens par tâche varie énormément selon le modèle, si bien qu'un même prix catalogue produit des factures très différentes. Ensuite, une fraction des tâches échoue, et une trajectoire ratée coûte quand même plein tarif. L'unité qui résiste à ces deux constats est le coût par tâche accomplie.

Une définition formelle

Définissons le coût d'une tentative comme la somme, sur les étapes de la trajectoire, des tokens facturés multipliés par leurs tarifs :

$$C_{\text{attempt}} = \sum_{s=1}^{S} \left( \text{in}_s \cdot p_{\text{in}} + \text{cache}_s \cdot p_{\text{cache}} + \text{out}_s \cdot p_{\text{out}} \right)$$

Si chaque tentative réussit indépendamment avec une probabilité $p$ et que vous relancez jusqu'à réussite, le nombre attendu de tentatives est $1/p$, donc :

$$\mathbb{E}[\text{coût par tâche résolue}] = \frac{C_{\text{attempt}}}{p_{\text{success}}}$$

Si vous plafonnez les relances à $N$ tentatives, la probabilité de réussite finale est $1 - (1-p)^N$ et le coût modèle attendu par tâche résolue augmente en conséquence. C'est le coût du modèle. Ce n'est pas le coût total.

Le coût total inclut les sorties erronées qui passent les contrôles automatisés et atteignent un humain ou la production :

$$\mathbb{E}[\text{coût total par tâche correcte}] = \frac{C_{\text{attempt}}}{p_{\text{success}}} + L \cdot K_{\text{cleanup}}$$

où $L$ est le taux de fuite, c'est-à-dire la probabilité qu'une sortie erronée ou non conforme échappe à la détection, et $K_{\text{cleanup}}$ le coût de sa correction. Ce terme est généralement invisible sur la facture d'API et souvent plus élevé que la facture elle-même.

Tarifs actuels (août 2026)

Anthropic, API standard, par million de tokens :

Modèle	Entrée	Sortie	Lecture cache	Batch (entrée/sortie)
Claude Fable 5	10 $	50 $	1,00 $	5 $ / 25 $
Claude Opus 5 (modèle phare par défaut)	5 $	25 $	0,50 $	2,50 $ / 12,50 $
Claude Opus 4.8	5 $	25 $	0,50 $	2,50 $ / 12,50 $
Claude Sonnet 5	2 $ (lancement) / 3 $	10 $ (lancement) / 15 $	0,30 $	1,50 $ / 7,50 $
Claude Haiku 4.5	1 $	5 $	0,10 $	0,50 $ / 2,50 $

Les écritures de cache Anthropic coûtent 1,25x le prix d'entrée pour le TTL de 5 minutes et 2x pour le TTL d'une heure. Le tarif de lancement de Sonnet 5 à 2 $ / 10 $ court jusqu'au 31 août 2026.

OpenAI, API standard, par million de tokens :

Modèle	Entrée	Sortie	Lecture cache	Batch (entrée/sortie)
GPT-5.6 Sol (modèle phare)	5 $	30 $	0,50 $	2,50 $ / 15 $
GPT-5.6 Terra	2 $	12 $	0,20 $	1 $ / 6 $
GPT-5.6 Luna	0,20 $	1,20 $	0,02 $	0,10 $ / 0,60 $
GPT-5.5	5 $	30 $	0,50 $	2,50 $ / 15 $
GPT-5.4	2,50 $	15 $	0,25 $	1,25 $ / 7,50 $

L'API Batch d'OpenAI applique 50 % de remise sur l'entrée comme sur la sortie, avec une fenêtre de 24 heures. Flex offre les mêmes 50 % à latence variable. Priority coûte environ 2,5x pour une latence réduite. GPT-5.6 a introduit une tarification des écritures de cache à 1,25x le prix d'entrée avec un minimum de 30 minutes, alignée sur le modèle d'Anthropic. Attention à la pénalité de contexte long : sur GPT-5.5 et GPT-5.6, toute requête dépassant environ 272 000 tokens d'entrée est facturée 2x en entrée et 1,5x en sortie pour toute la session. Anthropic inclut le contexte complet de 1M à tarif fixe sur Opus 5, Opus 4.8 et Sonnet 5.

Le coût par tâche, mesuré

Artificial Analysis publie un coût absolu en dollars par tâche sur son Intelligence Index. À effort de raisonnement maximal, en août 2026 : GPT-5.6 Sol coûte 1,04 $, Claude Opus 4.8 coûte 1,80 $, Claude Opus 5 coûte 2,03 $, Claude Sonnet 5 coûte 2,29 $ au tarif standard (1,53 $ au tarif de lancement, qui expire le 31 août 2026) et Claude Fable 5 coûte 2,75 $.

Sur cette suite, le modèle de pointe d'OpenAI offre une intelligence quasi maximale pour environ un tiers du coût du modèle le plus capable d'Anthropic. C'est le constat honnête, et il va à l'encontre de la thèse naïve.

Le classement est par ailleurs instable, exactement comme ce billet le prédit. Quand Artificial Analysis a publié son analyse du Coding Agent Index en mai 2026, Claude Opus 4.7 (max) dans Claude Code coûtait 4,10 $ par tâche contre 4,82 $ pour GPT-5.5 (xhigh) dans Codex — victoire de Claude. L'index en direct affiche désormais le même duo à environ 5,63 $ et 5,05 $ au 10 août, ordre inversé, parce que le coût par tâche est recalculé à partir des prix de tokens actuels et d'exécutions rafraîchies. Mêmes modèles, même benchmark, conclusion opposée en l'espace d'un trimestre. Dans la génération actuelle, GPT-5.6 Sol dans Codex mène l'index et revient environ 10 % moins cher par tâche qu'Opus 4.8 dans Claude Code. Le classement dépend du workload, de la génération et de la date — et c'est précisément le propos.

Exemple chiffré 1 : une tâche de codage où OpenAI gagne

Prenons une correction de bug de type SWE-bench. Modélisons la session avec mise en cache du prompt système et des outils.

Claude Opus 4.8 à 5 $ / 25 $, lecture cache à 0,50 $. Entrée effective de 1 000 000 tokens, 80 % de lectures cache, sortie de 40 000 tokens.

• Entrée : 200k tokens nouveaux à 5 $/M = 1,00 $, plus 800k lectures cache à 0,50 $/M = 0,40 $.
• Sortie : 40k à 25 $/M = 1,00 $.
• Écriture cache unique, 50k à 6,25 $/M = 0,31 $.
• $C_{\text{attempt}} \approx \$2.71$.

GPT-5.6 Sol à 5 $ / 30 $, lecture cache à 0,50 $. Sol est plus économe en sortie, modélisons donc 700 000 tokens d'entrée effectifs et 15 000 tokens de sortie.

• Entrée : 140k tokens nouveaux à 5 $/M = 0,70 $, plus 560k lectures cache à 0,50 $/M = 0,28 $.
• Sortie : 15k à 30 $/M = 0,45 $.
• Écriture cache unique, environ 0,07 $.
• $C_{\text{attempt}} \approx \$1.50$.

Divisons maintenant par le taux de réussite indépendant sur SWE-bench Verified via le harnais Vals AI : 96,2 % pour GPT-5.6 Sol, 88,6 % pour Claude Opus 4.8. Nous utilisons ici Opus 4.8 parce qu'il dispose d'une mesure indépendante Vals AI ; les chiffres publiés d'Opus 5 mélangent les harnais.

$$\text{Sol : } \frac{\$1.50}{0.962} \approx \$1.56 \text{ par issue résolue}$$ $$\text{Opus 4.8 : } \frac{\$2.71}{0.886} \approx \$3.06 \text{ par issue résolue}$$

OpenAI l'emporte ici à la fois sur le coût par tentative et sur le taux de réussite. Pour du codage autonome pur sur SWE-bench Verified public à la mi-2026, le modèle de pointe d'OpenAI, économe en tokens, est le choix le moins cher par issue résolue. Toute analyse honnête du coût par tâche doit le concéder.

Exemple chiffré 2 : une tâche d'utilisation d'outils où Anthropic gagne

Prenons maintenant un agent de support aérien autonome qui gère remboursements et re-réservations. Les actions erronées coûtent cher, car elles touchent de l'argent réel et des règles métier.

D'après le test tau-bench du Contra Collective, domaine aérien : Claude Opus 4.8 pass@1 = 0,64 avec 4 violations de règles pour 100 tâches. GPT-5.5 pass@1 = 0,58 avec 9 violations de règles pour 100 tâches. Il s'agit de dialogues plus courts, supposons donc des coûts par tentative d'environ 0,30 $ pour Opus et 0,22 $ pour GPT-5.5, plus économe en tokens. Supposons également que chaque violation non détectée coûte 25 $ à corriger, en cohérence avec les benchmarks 2026 de résolution en service desk.

Ce test est antérieur à GPT-5.6 Sol, le côté OpenAI a donc une génération de retard ; aucune exécution comparable de Sol sur tau-bench aérien n'a été publiée, et cette comparaison devra être refaite dès qu'il y en aura une.

Pour 100 tâches, relance jusqu'à réussite plus correction :

$$\text{Opus 4.8 : } 100 \cdot \frac{\$0.30}{0.64} + 4 \cdot \$25 = \$46.9 + \$100 = \$146.9 \;\Rightarrow\; \$1.47 \text{ par tâche correcte}$$ $$\text{GPT-5.5 : } 100 \cdot \frac{\$0.22}{0.58} + 9 \cdot \$25 = \$37.9 + \$225 = \$262.9 \;\Rightarrow\; \$2.63 \text{ par tâche correcte}$$

Le prix au token favorisait OpenAI. Le coût par tentative favorisait OpenAI. Le coût par tâche correcte, ajusté de la réussite et de la fiabilité, favorisait Anthropic de près de 2x, porté entièrement par le terme de correction. Le levier, c'est le coût d'une sortie erronée. Quand ce coût est élevé, la régularité de Claude se rentabilise d'elle-même. tau-bench rend cette régularité concrète : Opus 4.8 a maintenu 56 % des tâches sur 8 exécutions consécutives dans le retail contre 41 % pour GPT-5.5, et 34 % contre 22 % dans l'aérien. La régularité, voilà ce que vous achetez pour un fonctionnement sans supervision.

Distorsions liées au tokenizer et à la verbosité

Deux effets tirent en sens opposés. D'abord, le tokenizer d'Anthropic gonfle les décomptes de tokens : à prix égal par token, le coût effectif par mot de Claude est donc sous-estimé. Ensuite, la verbosité en sortie varie selon le modèle et le workload, et ici la donne s'est inversée en 2026. Des testeurs indépendants ont constaté que GPT-5.5 utilisait environ 72 % de tokens de sortie en moins que Claude Opus 4.7 sur des tâches de codage équivalentes, et Artificial Analysis a mesuré GPT-5.6 Sol consommant moins de tokens qu'Opus 4.8 tout en obtenant un meilleur score d'intelligence. La vieille hypothèse selon laquelle Claude serait le plus concis ne tient plus au niveau des modèles de pointe.

Verbosité ne rime pas avec capacité. L'article Terminal-Bench 2.0 (arXiv:2601.11868, ICLR 2026) n'a trouvé aucune relation statistiquement significative entre tokens de sortie et réussite (r = −0,170, p = 0,515), et a relevé que Claude Sonnet 4.5 et Claude Opus 4.1 atteignaient des taux de réussite de premier plan (43 % et 38 %) avec une consommation de tokens relativement modérée. Rien ne prouve que dépenser plus de tokens achète plus de justesse. Mais plus de tokens, c'est toujours une facture plus élevée : mesurez donc les tokens de sortie par tâche et par modèle plutôt que de supposer.

Facturation des tokens de raisonnement

Les deux fournisseurs facturent au tarif de sortie les tokens de réflexion, cachés ou semi-cachés. Les tokens de raisonnement d'OpenAI sont invisibles dans la réponse. Anthropic peut restituer une réflexion résumée. Opus 5 active désormais la réflexion adaptative par défaut, et chaque token de réflexion est facturé 25 $ par million — c'est pourquoi les tests à effort égal rapportent qu'Opus 5 émet environ deux fois plus de tokens de sortie qu'Opus 4.8 sur une même tâche. Conséquence pratique : c'est souvent le réglage d'effort, pas le choix du modèle, qui fait le plus bouger la facture. Instrumentez les tokens de raisonnement séparément de la sortie visible.

Mise en cache

Le prompt caching est le levier le plus puissant sur les longues sessions agentiques. Les deux plateformes facturent les lectures de cache à 10 % du prix d'entrée. Anthropic utilise des points de rupture cache_control explicites et facture 1,25x pour une écriture de 5 minutes ou 2x pour une écriture d'une heure. OpenAI met en cache automatiquement au-delà d'environ 1 024 tokens de préfixe stable. Dans une boucle d'agent, le prompt système, les schémas d'outils et un préfixe de conversation croissant se répètent à chaque tour : exactement la configuration pour laquelle le cache a été conçu. L'accumulation de tokens dans une boucle est quadratique. Les lectures de cache la ramènent vers du linéaire.

ProjectDiscovery a fait passer son taux de hits de cache de 7 % à 84 % tout en servant 9,8 milliards de tokens depuis le cache, réduisant sa dépense LLM réelle de 59 %, avec des exécutions post-optimisation atteignant 66 % et les 10 derniers jours à 70 %. Une boucle qui se déclenche au moins toutes les 5 minutes garde son cache Anthropic actif indéfiniment, en ne payant la prime d'écriture qu'une seule fois. Placez le contenu stable en premier. Tout ce qui suit un élément variable n'est pas mis en cache.

Coûts cachés

La facture d'API est le coût visible. Le coût caché, c'est le temps humain passé sur les sorties erronées. Une étude de 2025 citée par LogRocket a constaté que les ingénieurs seniors passent en moyenne 4,3 minutes à examiner une suggestion générée par l'IA contre 1,2 minute pour du code écrit par un humain, et l'analyse de Faros AI portant sur plus de 10 000 développeurs a relevé une hausse de 98 % du volume de pull requests accompagnée d'une hausse de 91 % du temps de revue.

Faros a aussi constaté, sur 211 tâches d'ingénierie réelles, qu'un modèle moins cher, doté du bon contexte de dépôt et d'une boucle de vérification, peut battre un modèle plus puissant travaillant à l'aveugle : l'ingénierie du contexte et du harnais déplace donc la frontière qualité-coût elle-même, parfois plus que le choix du modèle. Et ces coûts retombent sur les personnes les plus chères et les plus sollicitées de l'équipe.

Comment instrumenter le coût par tâche

Consignez les tokens par trajectoire, pas par appel. Taguez chaque requête avec un identifiant de tâche. Additionnez les tokens d'entrée, de lecture cache, d'écriture cache, de raisonnement et de sortie visible sur l'ensemble de la boucle.

Enregistrez le résultat. Marquez chaque tâche comme résolue ou échouée via un contrôle automatisé, et consignez les relances.

Calculez le coût ajusté du taux de réussite : le total en dollars des trajectoires divisé par le nombre de tâches résolues. C'est votre véritable unité.

Suivez un taux de fuite. Échantillonnez des tâches terminées ayant passé les contrôles automatisés et faites évaluer par un humain la justesse ou la conformité aux règles. Multipliez le taux de fuite par votre coût de correction toutes charges comprises.

Communiquez un coût par unité. Par ticket résolu, par PR fusionnée ou par action correcte, par modèle et par réglage d'effort. Rendez-le visible pour l'équipe qui le génère.

Séparez dès la conception le travail interactif du travail batchable. Routez la moitié batchable vers Batch ou Flex pour bénéficier de 50 % de remise.