← Tous les articles

Mesure

Ce que Claude Code coûte vraiment : où vont les tokens

Le tableau des offres est la moitié facile de la question du prix. La moitié chère, c'est ce qu'une session fait à votre contexte, tour après tour — et cette partie-là se compte.

Rédigé par Ted Mavera, Product Manager chez HarnessUp, l'entreprise qui fait l'outil décrit ici. Les textes de ce blog sont rédigés avec l'aide de l'intelligence artificielle et relus par l'équipe avant publication.

Une machine en métal faisant passer des pages en boucle par une ouverture violette lumineuse, à côté d'un tiroir en verre de pages en cache, et une seule feuille posée au sol.

Pourquoi cet article existe

Cherchez ce que coûte Claude Code et vous tomberez quarante fois sur la même page : un tableau avec les paliers d'abonnement, un paragraphe sur les limites, et un verdict qui dépend de ce que l'auteur bricolait cette semaine-là. Le tableau est exact et presque inutile. Il répond à ce que vous payez pour entrer. Il ne répond pas à pourquoi la session de mardi semblait trois fois plus lourde que celle de lundi, sur le même forfait, dans le même dépôt.

La deuxième question a une réponse arithmétique, et cette réponse est déjà sur votre machine. Cet article la parcourt : ce qu'un tour renvoie réellement, laquelle des quatre lignes de la facture domine, et où le gaspillage se cache dans le travail ordinaire. Nous laisserons le produit de côté jusqu'au dernier tiers, parce que la méthode tient sans lui — et parce qu'une décomposition des coûts qui ne fonctionne que si vous achetez quelque chose n'est pas une décomposition.

La seule multiplication qui explique la facture

Un tour, c'est un aller-retour vers le modèle. Tout ce qui a été dit dans la conversation jusqu'ici part avec lui, sauf si le harness compacte ou si vous repartez de zéro. C'est toute l'astuce, et c'est la raison pour laquelle un fichier lu une fois n'est pas payé une fois. Notre documentation le met en une unité, le token-turn : les tokens multipliés par le nombre de tours pendant lesquels un contenu survit dans le contexte.

8 000 tokens × 30 tours = 240 000 token-turns
15 000 tokens × 37 tours = 555 000 token-turns

Relisez-le deux fois, car cela réordonne l'intuition que la plupart des gens apportent ici. Un outil qui écrit moins de code n'est pas celui qui économise le plus. Celui qui économise le plus est celui qui retire du contexte ce qui a déjà servi. Un fichier de 15k qui arrive au tour 4 et ne repart jamais coûte plus de trois fois un fichier de 8k qui arrive au tour 1 — et c'est le second que les gens essaient généralement d'optimiser.

Quatre lignes, pas une : de quoi la facture est faite

La facture d'Anthropic découpe l'entrée en trois tranches : entrée nouvelle, écriture de cache et lecture de cache, plus la sortie. Ce découpage compte parce que les trois tranches d'entrée n'ont pas le même prix, et parce qu'elles évoluent en sens inverse à mesure qu'une session grandit. Les lectures de cache coûtent une fraction du prix d'entrée de base, ce qui ressemble à une bonne affaire jusqu'à ce que vous vous rappeliez qu'une lecture de cache a lieu à chaque tour. Les écritures de cache coûtent plus cher que l'entrée simple et ne s'amortissent que si le bloc est relu avant l'expiration du cache.

Cette échéance est la partie que la plupart des articles sur les prix omettent. Un cache de prompt est un bail à court terme, et le compteur repart à zéro quand il expire. Le minuteur de cache de la démo Utilities existe exactement pour cela : il montre un cache chaud qui refroidit après quelques minutes d'inactivité, pour que vous puissiez voir le moment où un long déjeuner augmente discrètement le prix de votre tour suivant. Les pourcentages changent avec la grille tarifaire ; le mécanisme, non.

Concrètement, c'est pourquoi deux sessions avec le même nombre de prompts peuvent coûter très différemment. L'une garde un préfixe stable et reste chaude. L'autre modifie des fichiers en haut du contexte, casse le préfixe un tour sur trois, et paie à chaque fois la réécriture du cache.

Quatre colonnes de lumière translucide empilées sur un bureau sombre, trois étroites et une plus large, chacune marquée d'un petit compteur différent et réunies à la base.
Quatre lignes, une facture : entrée nouvelle, cache écrit, cache lu et sortie.

Où vont réellement les tokens

Cinq catégories expliquent la majeure partie du poids évitable d'une journée de travail normale. Aucune n'est exotique. Toutes sont visibles dans la transcription locale, après coup.

1. Le contexte qu'on relit sans arrêt

Chaque message que vous envoyez traîne derrière lui toute la conversation. Au tour 40, le fichier que vous avez ouvert au tour 3 monte toujours dans le train, occupe toujours un siège, est toujours facturé. Le remède habituel — une nouvelle session — fonctionne, mais les gens choisissent le mauvais moment : ils redémarrent quand la conversation leur paraît longue, au lieu de quand le coût par tour dépasse le coût de reconstruction du contexte. Ce sont deux points différents, et un seul est celui où renouveler rapporte.

2. Le fichier entier pour une fonction

Demander à un agent de corriger validate() livre généralement tout auth.ts. Ensuite le fichier entier reste dans le contexte pour les tours restants, l'essentiel étant hors sujet. Le même gaspillage apparaît dans l'autre sens : une recherche qui renvoie six cents lignes correspondantes alors que les vingt premières suffisaient pour décider.

3. La sortie d'outil que personne ne lit

Une exécution de tests qui imprime neuf cents lignes, un journal de build d'un monorepo, le HTML d'une page de documentation récupérée pour vérifier un paramètre. La transcription garde tout. Le modèle lit tout au tour suivant, qu'il en ait besoin ou non.

4. Les tours passés à découvrir que le code ne compile pas

Une modification atterrit, l'agent annonce que c'est fait, vous demandez la suite, et c'est seulement là que quelqu'un lance le build. Il y a maintenant un aller-retour pour découvrir une erreur de syntaxe qu'un compilateur aurait signalée en deux secondes, plus un autre pour la corriger, plus le coût des deux qui restent dans le contexte. Un après-midi normal, c'est le poste le plus discret des cinq et, d'après notre expérience, le plus agaçant à regarder.

5. La réponse avec un préambule

« Excellente question — laissez-moi vous expliquer ce que je vais faire. » Cela coûte des tokens de sortie une fois et des tokens d'entrée à chaque tour ensuite, parce que la réponse fait désormais partie de l'historique. Multipliez une habitude par quarante tours et elle devient une ligne sur la facture.

Ce que le palier change, et ce qu'il ne change pas

Les offres Claude Code se comptent en fenêtres — des blocs de cinq heures et un plafond hebdomadaire — et c'est cette structure qui fait tourner en rond la conversation sur les prix. Une offre plus grande achète de la marge à un prix plus élevé. Elle ne change pas le fait qu'un fichier de 15k coûte 15k à chaque tour, et elle ne rend pas une relecture moins chère. Montez assez de fois de palier et le gaspillage grandit avec l'offre.

La version honnête : si votre travail est réellement volumineux, une offre plus grande est le bon achat. La question qu'il vaut la peine de poser d'abord est de savoir si le travail est volumineux ou si le contexte est simplement lourd. De l'extérieur, les deux se ressemblent et les remèdes sont très différents.

Mesurez avant de décider quoi que ce soit

Si cet article peut être précis, c'est parce que les chiffres sont locaux. Claude Code écrit les transcriptions sur le disque, avec l'usage réel de tokens par tour, et une couche de mesure peut les lire sans rien envoyer nulle part. Notre front Metering existe pour ça et il est gratuit : Deep Scan parcourt les conversations enregistrées et décompose la dépense par source, Harness History ouvre le reçu de chaque session close, Inside the Wallet sépare entrée nouvelle, lecture de cache, cache écrit et sortie par modèle, et Plan Usage montre ce que chaque fenêtre a rendu avant que la limite se renouvelle.

Commencez par la session la plus laide de la semaine dernière, pas par une moyenne. Les moyennes cachent la forme du problème, et c'est la forme qui est actionnable : un fichier géant lu au tour 2, un journal au milieu, une réponse qui a divagué sur six cents tokens puis qui a été relue trente fois.

Où HarnessUp intervient

C'est la partie où nous vendons quelque chose, donc elle arrive avec le chiffre et l'offre qu'il exige. HarnessUp est une couche locale qui agit par les hooks officiels de Claude Code et de Codex — pas un proxy, pas un serveur MCP, rien qui lise votre token ou votre clé. Il compte 151 outils sur dix fronts, et une bonne partie du front Savings correspond une à une aux cinq catégories ci-dessus.

Renew Session marque le tour où continuer coûte plus cher que redémarrer, et dans un contrefactuel mesuré sur un historique réel, le basculement a atteint 73 % du contexte payé. Code Finder renvoie le squelette d'un grand fichier à la première lecture et le corps seulement sur demande ; Delta Read refuse le passage d'un fichier que l'agent a déjà vu ; Head Limit plafonne un grep qui renvoie une encyclopédie ; Terminal Guide et Output Diet gardent le début, la fin et les lignes d'erreur d'un long journal. First Pass compile juste après la modification, pour qu'un build cassé voyage avec le tour suivant au lieu de coûter un tour à lui. Response Diet coupe le texte d'échauffement. Memory State découpe le fichier de contexte en fragments immuables et a mesuré 4,27 % de contexte avec 298 tours de survie.

Le chiffre le plus gros que nous ayons est moins glamour et plus utile : Build Now, qui lance le build à la fin d'un message sans dépenser un tour de modèle, a enregistré 2 769 builds et 806,7 M de tokens d'entrée relus qui n'ont pas eu lieu. Aucun de ces chiffres n'est le vôtre. Ils sont ce que l'instrument a mesuré sur les machines qui l'ont fait tourner, ce qui est la façon honnête de présenter un contrefactuel — et la raison pour laquelle le panneau montre vos propres coupes séparément de l'estimation.

Ce que cette décomposition ne promet pas

Tous les tokens d'une session ne sont pas du gaspillage, et un outil qui prétendrait le contraire vous mentirait d'une manière facile à vérifier. Lire un fichier dont vous avez besoin n'est pas du gaspillage. Le relire au tour suivant est une taxe que vous payez pour la mémoire du modèle, et une partie de cette taxe est le prix du travail. L'intérêt de l'arithmétique est plus étroit : séparer ce que la tâche exigeait de ce que le harness a toléré, puis décider laquelle des deux vous voulez payer.

Elle ne promet pas non plus qu'une session moins chère soit plus rapide. Compresser un journal ou couper un préambule change ce que le modèle voit, et il existe des cas où le détail coupé était le détail qui comptait. C'est pourquoi chaque outil ici est réversible, et pourquoi la couche de mesure est gratuite : vous devriez pouvoir voir l'échange avant de l'accepter.

Commencez par votre propre facture. Installez HarnessUp gratuitement, lancez Deep Scan sur les sessions de la semaine dernière et trouvez la ligne qui ne devrait pas être là.

Installer gratuitement