Comment estimer le coût d'un agent IA

Un agent IA ne fait pas une seule requête — il en fait des dizaines, et chaque étape renvoie la conversation qui s'allonge. C'est pourquoi les factures des agents sont dominées par les tokens d'entrée, et pourquoi l'intuition du « prix par réponse » des applications de chat ne fonctionne pas. Voici comment estimer le coût avant que l'agent ne s'exécute, et où va réellement l'argent.

La formule#

Le coût d'une requête est le nombre de tokens d'entrée multiplié par le prix d'entrée plus le nombre de tokens de sortie multiplié par le prix de sortie. Les prix sont indiqués par million de tokens :

request_cost = input_tokens / 1,000,000 × input_price
             + output_tokens / 1,000,000 × output_price

Le coût d'une tâche est la somme sur toutes les requêtes que l'agent effectue pour la résoudre.

Pourquoi les agents consomment beaucoup d'entrée#

À chaque étape, l'agent envoie au modèle :

• le prompt système et les définitions d'outils ;
• tout l'historique jusqu'ici — messages précédents, réponses précédentes du modèle et résultats d'outils (contenu de fichiers, sortie de commandes, résultats de recherche) ;
• la nouvelle instruction.

Le modèle répond généralement par un court message ou un appel d'outil. Ensuite, le résultat de l'outil est ajouté à l'historique et l'étape suivante renvoie tout à nouveau. Ainsi, l'entrée de chaque étape augmente, tandis que la sortie reste petite.

Un exemple concret#

Conditions (hypothèses — remplacez-les par les chiffres de votre agent) :

• prompt système et définitions d'outils : 6 000 tokens ;
• chaque étape ajoute 1 500 tokens de résultats d'outils et 500 tokens de sortie du modèle à l'historique ;
• la tâche prend 30 étapes ;
• modèle : DeepSeek-V4-Flash à $0.0221 par 1M de tokens d'entrée et $0.10 par 1M de tokens de sortie (prix actuels).

L'entrée de l'étape n est de 6 000 + (n − 1) × 2 000 tokens. Sur 30 étapes :

• entrée totale : 30 × 6 000 + 2 000 × (0 + 1 + … + 29) = 180 000 + 870 000 = 1 050 000 tokens ;
• sortie totale : 30 × 500 = 15 000 tokens ;
• coût : 1,05 × $0.0221 + 0,015 × $0.10 ≈ $0.0247 par tâche.

L'entrée représente 98,6 % des tokens et la quasi-totalité du coût. La part dominante de l'entrée dépend du scénario : les réponses longues, les fichiers générés et les modèles de raisonnement augmentent la part de sortie, tandis qu'un historique réduit et une sortie d'outil courte diminuent la part d'entrée.

La même tâche sur chaque modèle aux prix actuels, avec les prix de référence d'OpenRouter pour comparaison :

Estimez-le en code#

Le même calcul sous forme de fonction — modifiez les hypothèses et les prix :

def estimate(steps, base_tokens, tool_tokens, out_tokens, price_in, price_out):
    """Token totals and cost of one agent task. Prices: $ per 1M tokens."""
    grow = tool_tokens + out_tokens            # what each step adds to the history
    total_in = steps * base_tokens + grow * steps * (steps - 1) // 2
    total_out = steps * out_tokens
    cost = (total_in * price_in + total_out * price_out) / 1_000_000
    return total_in, total_out, round(cost, 5)

# example rates, $ per 1M tokens — put in the current ones from the pricing table below
print(estimate(30, 6_000, 1_500, 500, price_in=0.10, price_out=0.40))
# (1050000, 15000, 0.111)

Notez le terme quadratique : doubler le nombre d'étapes quadruple à peu près l'entrée. Les longues sessions deviennent coûteuses non pas à cause d'une étape en particulier, mais parce que chaque étape transporte tout l'historique.

Mesurez au lieu de deviner#

Chaque réponse inclut usage.prompt_tokens (entrée) et usage.completion_tokens (sortie). Enregistrez-les pour chaque étape d'une tâche réelle, multipliez par les tarifs actuels, et vous obtenez le coût réel. Le tableau de bord affiche aussi l'utilisation par modèle et par jour.

Tarifs actuels — les mêmes données que sur la page de tarification :

Sept façons de réduire le coût#

1. Démarrez une nouvelle tâche pour un travail sans rapport. Une session fraîche ne transporte pas l'historique de la précédente.
2. Donnez des fragments à l'agent, pas des fichiers entiers. Une fonction et ses appelants plutôt qu'un module de 3 000 lignes.
3. Tronquez la sortie des outils. Les longs journaux et sorties de commandes restent dans l'historique pour le reste de la session — limitez-les, par exemple avec | tail -n 50.
4. Résumez les longues sessions. De nombreux agents peuvent compacter l'historique ; utilisez-le avant que le contexte ne devienne long.
5. Limitez la longueur de la réponse avec max_tokens là où les réponses longues ne sont pas nécessaires.
6. Utilisez le bon modèle pour l'étape. Les étapes routinières n'ont pas besoin d'un modèle de raisonnement.
7. Gardez un budget prépayé. Le solde est prépayé : lorsqu'il est épuisé, les requêtes s'arrêtent avec un HTTP 402 au lieu de faire grimper une facture ouverte.

Pour voir comment la même charge de travail se compare entre les modèles et avec OpenRouter, utilisez la comparaison des coûts sur la page d'accueil.