Pourquoi vos agents IA consomment 30x plus de tokens que vous ne le pensez

Le prix des tokens a chuté d'environ 80% entre 2025 et 2026. Les dépenses LLM en entreprise ont quand même doublé. Si cela semble contradictoire, c'est parce que tout le monde mesure la mauvaise variable — le prix par token — alors que ce qui fait vraiment grimper la facture, c'est le nombre de tokens qu'une seule tâche consomme désormais.

Le paradoxe que personne n'avait anticipé

Toutes les annonces des fournisseurs depuis dix-huit mois parlent de tokens moins chers. Et ce n'était pas un mensonge — le prix par token s'est réellement effondré. Pourtant, les dépenses d'API IA en entreprise ont dépassé 8,4 milliards de dollars en 2025 et sont en passe de doubler à nouveau, l'inférence représentant désormais environ 85% du budget IA moyen. L'écart entre "les tokens coûtent moins cher" et "les factures explosent" a un nom : les agents.

Un chatbot répond à une question et s'arrête. Un agent planifie, appelle un outil, lit le résultat, réévalue, appelle un autre outil, vérifie son propre travail, et recommence parfois depuis le début. Chacune de ces étapes renvoie le contexte accumulé, et chacune est facturée. Selon l'analyse de Gartner de mars 2026, les workflows agentiques consomment 5 à 30 fois plus de tokens par tâche complétée qu'une interaction chatbot classique équivalente. Certaines équipes utilisant des boucles d'appels d'outils intensives rapportent des chiffres proches de 50x sur leurs charges les plus lourdes.

Ce qui se passe réellement dans la boucle

Un agent n'est pas un seul appel API — c'est une chaîne d'appels, et cette chaîne s'accumule de façons faciles à manquer tant qu'on n'a pas regardé le log brut des requêtes :

• La retransmission du contexte. Comme toute conversation multi-tours, chaque étape renvoie l'historique complet : la tâche initiale, chaque résultat d'outil obtenu jusqu'ici, chaque étape de raisonnement intermédiaire. Un run d'agent de 20 étapes ne coûte pas 20x un appel unique — il coûte la somme d'un contexte qui grossit rapidement, à chaque étape.
• Les retries d'appels d'outils. Un appel API échoué, un argument JSON mal formé, un outil qui renvoie une erreur — l'agent réessaie généralement, et chaque nouvelle tentative est un aller-retour facturable complet, contexte inclus.
• Les passes d'auto-vérification. Les frameworks d'agents modernes ajoutent par défaut une étape "vérifie ton propre résultat", car cela améliore mesurablement le taux de réussite des tâches. Cela double aussi à peu près le coût en tokens de chaque tâche qui l'utilise.
• Les sous-agents en parallèle. Les patterns d'orchestration qui répartissent une tâche entre plusieurs sous-agents multiplient le coût de base par le nombre de sous-agents lancés — souvent sans qu'un humain ait explicitement choisi ce multiplicateur. C'est un réglage par défaut du framework, pas un arbitrage délibéré.

Le week-end à 4 200 $

Ce n'est pas théorique. Un incident largement cité : un développeur ayant laissé tourner un agent de refactoring autonome sur un projet client tout un long week-end s'est retrouvé avec 4 200 $ de frais d'API, sans surveillance, avant que quiconque ne s'en aperçoive. Aucun appel individuel n'était anormal. L'agent a simplement continué à travailler, à relire son contexte, à réessayer les étapes échouées — et personne ne surveillait le compteur en temps réel.

C'est le schéma derrière une statistique plus large qui devrait inquiéter toute direction financière adoptant des outils agentiques : 60% des projets IA dépassent désormais leur estimation de coût initiale de 30 à 50%, et 85% des entreprises ratent leurs prévisions de coûts IA de plus de 10% — un quart d'entre elles de 50% ou plus. Ces estimations ne sont pas fausses parce que les équipes savent mal compter. Elles sont fausses parce qu'elles reposaient sur des hypothèses de l'ère chatbot concernant le nombre de tokens par tâche, et les agents ont discrètement cassé cette hypothèse.

Pourquoi ça reste invisible jusqu'à la facture

Une seule étape d'agent a l'air parfaitement normale, isolément — quelques centaines de tokens de résultat d'outil, un appel API qui semble raisonnable. Rien ne déclenche d'alarme. Le coût ne devient visible qu'en agrégeant l'ensemble de la chaîne de tâche, et la plupart des équipes n'ont pas cette vue. Elles ont des logs par requête, pas des cumuls de coût par tâche. Le temps que quelqu'un construise la requête qui additionne un run d'agent de bout en bout, la dépense a déjà eu lieu depuis des semaines.

C'est aussi pourquoi les annonces de prix par token sont activement trompeuses pour établir un budget. Une baisse de prix de 50% sur le modèle sous-jacent ne veut rien dire si la même tâche passe désormais par trois fois plus d'étapes facturables qu'il y a six mois, sur la version précédente de votre framework d'agent.

Ce qu'il faut instrumenter avant de déployer des agents à grande échelle

Les équipes qui maîtrisent le coût de leurs agents partagent la même instrumentation, mise en place avant la mise en production plutôt qu'après la première facture surprise :

• Le coût par tâche complétée, pas par appel API. Taguez chaque étape d'un run d'agent avec un identifiant de tâche partagé et cumulez le coût au niveau de la tâche. Un appel qui a l'air bon marché isolément ne vous dit rien ; une tâche qui coûte 8 € pour accomplir un travail à 0,50 € vous dit tout.
• Un plafond d'étapes strict. Limitez le nombre maximal d'itérations d'appels d'outils par tâche. La plupart des dérapages de coût sont des boucles qui auraient dû s'arrêter et ne l'ont pas fait.
• Des garde-fous budgétaires par agent et par run. Un plafond en euros par tâche, appliqué en temps réel, pas revu après coup. C'est le contrôle unique qui aurait arrêté le week-end à 4 200 $ à 200 $.
• Le suivi isolé du coût des retries et de l'auto-vérification. Sachez quelle part de votre dépense agent est la tâche réelle par rapport au surcoût — retries, re-vérifications, re-planification. Ce ratio vous dit exactement où optimiser en premier.
• La détection d'anomalies au niveau de la tâche, pas seulement du total quotidien. Un graphique de dépense quotidienne lisse le seul run d'agent qui a coûté 40x ses pairs. Les baselines par tâche le repèrent immédiatement.

En résumé

Des tokens moins chers n'allaient jamais sauver votre budget à eux seuls, car les agents n'achètent pas moins de tokens avec les économies — ils dépensent les mêmes dollars en plus d'étapes. Les équipes qui feront tourner l'IA agentique de façon rentable en 2026 ne sont pas celles qui attendent la prochaine baisse de prix. Ce sont celles qui peuvent voir, tâche par tâche, exactement où chaque token est parti — et qui ont posé un plafond sur la boucle avant d'en avoir besoin.