Pourquoi les agents IA utilisent autant de tokens (un exemple en 20 étapes)

Vous posez une question à un agent, il travaille quelques minutes, et la page d'utilisation affiche des centaines de milliers de tokens. Rien n'est cassé. Un agent est une boucle, et chaque tour de la boucle renvoie tout ce qui a été dit jusqu'ici (la liste des outils, l'historique, tout ce que les outils ont renvoyé) en tokens d'entrée. La réponse qu'il écrit est minuscule. Ce qu'il relit encore et encore ne l'est pas.

Ce qu'est un agent, en une image#

Un modèle de chat répond une fois. Un agent est le même modèle dans une boucle avec des outils : lire un fichier, chercher sur le web, exécuter une commande. Et le modèle ne se souvient de rien entre les appels. Imaginez un assistant qui oublie tout à chaque fois qu'il raccroche : à chaque rappel, vous relisez les notes depuis le début, puis ajoutez une ligne. C'est ainsi que fonctionne l'API.

La documentation d'Anthropic sur l'utilisation des outils (consultée le 26 octobre 2026) décrit la boucle ainsi :

1. Votre application envoie le message de l'utilisateur et la liste des outils.
2. Le modèle répond avec stop_reason: "tool_use" et un bloc tool_use : quel outil, avec quels arguments.
3. Votre application exécute l'outil et envoie une seconde requête. Elle contient les messages précédents, l'appel d'outil du modèle, un bloc tool_result et la même liste d'outils.
4. Le modèle répond, ou demande un autre outil, et la boucle recommence.

La même page indique que les requêtes d'utilisation d'outils sont facturées sur le total d'entrée envoyé, paramètre tools inclus, plus la sortie. Donc l'étape 3 n'est jamais « juste la nouvelle partie » : c'est toute la conversation à nouveau.

Request 1  tools + system + task
Request 2  tools + system + task + call 1 + result 1
Request 3  tools + system + task + call 1 + result 1 + call 2 + result 2
...

C'est le même mécanisme que dans pourquoi une longue conversation coûte plus cher, en plus rapide. Une conversation grandit d'un message quand vous tapez. Un agent grandit de deux blocs à chaque étape, et personne ne tape rien.

Trois choses accompagnent chaque étape#

La liste des outils. Noms, descriptions et schémas de paramètres de chaque outil entrent dans chaque requête, même quand le modèle n'en utilise aucun ce tour-ci. La documentation ajoute un petit supplément : avec les outils activés, l'API ajoute son propre prompt d'utilisation d'outils, 286 tokens sur Claude Sonnet 5.5, Opus 5.5 et Haiku 5.5, et les autres modèles ont d'autres comptes.

L'historique. Votre tâche, les appels d'outils précédents du modèle, ses notes.

La sortie des outils. C'est la plus sournoise. Un fichier que l'agent a lu, une page de résultats de recherche, un journal de test : une fois qu'il atterrit dans l'historique, il est payé à nouveau à chaque étape suivante.

Un token est un petit morceau de texte, à peu près un mot court ou une partie de mot, et chacun de ces trois éléments est compté en tokens.

Une exécution de 20 étapes, comptée#

Supposons que vous exécutiez un petit agent de codage avec trois outils (lire un fichier, chercher, exécuter des tests) et que vous lui donniez une tâche qui prend 20 étapes. Prenons ces hypothèses :

• définitions d'outils : 1 500 tokens, prompt système : 500, votre tâche : 200, donc chaque requête commence à 2 200 tokens ;
• à chaque étape, le modèle écrit un appel d'outil de 150 tokens, et l'outil renvoie 800 tokens ;
• les deux rejoignent l'historique, donc chaque étape ajoute 950 tokens à la requête suivante.

Pour obtenir le total de l'exécution, additionnez les 20 requêtes. La base de 2 200 est envoyée 20 fois, et les tours sont reportés par les étapes suivantes : l'étape 1 n'en reporte aucun, l'étape 2 un, et ainsi de suite jusqu'à 19, ce qui fait 190 tours au total.

20 × 2 200 = 44 000

950 × 190 = 180 500

44 000 + 180 500 = 224 500 tokens d'entrée, et 20 × 150 = 3 000 tokens de sortie.

L'agent a écrit 3 000 tokens et en a lu 224 500. Les tokens de sortie coûtent plus cher à l'unité que les tokens d'entrée (voir tokens d'entrée vs sortie), mais il y en a si peu que le côté entrée décide toujours de la facture. Voici cette exécution aux prix actuels :

Sur DeepSeek-V4-Flash, une telle exécution revient à $0.0037, sur GLM-5.3-Flash à $0.0046. Cent exécutions représentent 22 450 000 tokens d'entrée et 300 000 tokens de sortie : $0.367 sur DeepSeek-V4-Flash. Le tableau ci-dessus compte l'entrée et la sortie ensemble, et au total les modèles qui y figurent reviennent moins cher qu'OpenRouter.

Le nombre d'étapes compte plus qu'il n'y paraît. Une exécution de 5 étapes avec les mêmes hypothèses :

5 × 2 200 = 11 000

950 × 10 = 9 500

11 000 + 9 500 = 20 500 tokens d'entrée. Quatre fois plus d'étapes ont donné environ onze fois plus d'entrée, parce que chaque nouvelle étape relit aussi toutes les anciennes.

Où réduire : quatre habitudes#

Le résultat d'un outil est l'endroit le plus facile pour économiser. Supposons qu'une exécution de test à l'étape 3 renvoie un journal de 4 000 tokens. Il est ensuite renvoyé par les 17 requêtes qui suivent :

• avant : 4 000 × 17 = 68 000 tokens d'entrée portés par ce seul journal ;
• après, si l'outil ne renvoie que les 40 lignes pertinentes (environ 400 tokens) : 400 × 17 = 6 800.

Même tâche, même réponse, un dixième de l'entrée provenant de ce seul résultat. Cela donne quatre habitudes :

• Renvoyez moins de choses depuis les outils. Les lignes autour de l'erreur, pas tout le journal ; la fonction, pas tout le fichier. Il y a un développement plus long dans garder la sortie des outils hors du contexte.
• Donnez moins d'outils à l'agent. Chaque définition accompagne chaque requête.
• Limitez le nombre d'étapes et démarrez une nouvelle tâche quand l'ancien historique n'a plus d'importance.
• Additionnez l'utilisation de chaque étape, et arrêtez l'exécution à un budget que vous avez choisi à l'avance. Pour le côté estimation, voir comment estimer le coût d'un agent IA.

Comptez votre propre exécution#

Chaque réponse indique combien de tokens elle a pris en entrée et produit en sortie, dans son champ usage. Additionnez-les sur toutes les étapes et vous obtenez les vrais chiffres de votre agent au lieu de mes hypothèses. Un exemple avec le SDK Python OpenAI pointé vers CheapTokens (messages et tools sont ceux de votre agent) :

from openai import OpenAI

client = OpenAI(base_url="https://api.cheaptokens.dev/v1", api_key="YOUR_API_KEY")

total_in = total_out = 0
for step in range(20):  # your agent loop
    resp = client.chat.completions.create(
        model="deepseek-ai/DeepSeek-V4-Flash-0731",
        messages=messages,
        tools=tools,
    )
    total_in += resp.usage.prompt_tokens
    total_out += resp.usage.completion_tokens
    # ...run the tool, append the result to messages

print(total_in, total_out)

Les deux totaux s'insèrent directement dans le tableau de coûts ci-dessus. Pour de longs historiques comme celui-ci, DeepSeek-V4-Flash vous offre une fenêtre de contexte de 380K et jusqu'à 32 768 tokens de sortie par réponse, à un prix unique à toute heure ; GLM-5.3-Flash a un contexte de 390K et jusqu'à 8 192 tokens de sortie. La configuration est dans la documentation, le prix actuel de chaque modèle est sur la page de tarification, et le modèle a sa propre page, DeepSeek pas cher.