Contrôle des coûts LLM pour les agents : 5 garde-fous pour limiter les dépenses

Un agent sain de 12 étapes exécuté sur Claude Sonnet 5 coûte environ 0,39 $. Le même agent bloqué dans une boucle de 200 étapes coûte environ 74 $, car son contexte croît de 1 800 tokens par étape et chaque étape renvoie tout ce contexte : 36,7 millions de tokens d'entrée au total. Sur Claude Opus 5 ou GPT-5.5, la même boucle coûte environ 185 $. Cinq garde-fous l'arrêtent : max_tokens par appel, un plafond d'étapes par exécution, une condition d'arrêt explicite, un budget en dollars par exécution calculé à partir des champs usage de chaque réponse, et un plafond quotidien dans la console du fournisseur.

Les trois premiers tiennent en une ligne chacun. Le quatrième est l'exécuteur de 30 lignes ci-dessous. Le cinquième est un paramètre de console. Appliquez les cinq, car chacun rattrape une défaillance que les autres manquent.

Les agents ne tombent généralement pas en panne en produisant une seule réponse énorme. Ils tombent en panne en répétant une petite étape, apparemment raisonnable, encore et encore. Les modes de défaillance que nous voyons le plus souvent :

• Un outil qui renvoie un message d'erreur que le modèle traite comme une invite à réessayer, avec les mêmes arguments, indéfiniment
• Une instruction « vérifiez votre travail » que le modèle satisfait en réexécutant toute la tâche
• Un outil de recherche qui renvoie des résultats légèrement différents à chaque appel, de sorte que le modèle n'a jamais l'impression d'avoir terminé
• Deux agents qui se renvoient une tâche, chacun croyant que l'autre est responsable de la terminer
• Un stop_reason de max_tokens que le code de la boucle traite comme « rappeler » au lieu de « quelque chose ne va pas »

Aucun de ces scénarios ne semble coûteux à l'étape 5. Ils le deviennent à l'étape 80, lorsque le contexte atteint 147 000 tokens et que chaque étape coûte plus que les vingt premières réunies. Les mécanismes de cette croissance sont détaillés dans [combien coûte l'exécution d'un agent IA](/guides/how-much-does-an-ai-agent-cost-to-run).

Trace de référence : préfixe de 4 000 tokens, tâche de 500 tokens, chaque étape ajoute un appel d’outil de 300 tokens et un résultat de 1 500 tokens. Entrée à l’étape k : 4 500 + 1 800 × (k − 1). Somme sur 200 étapes : 200 × 4 500 + 1 800 × 19 900 = 36 720 000 tokens d’entrée. Sortie : 200 × 300 = 60 000 tokens. Contexte à l’étape 200 : 362 700 tokens, ce qui tient dans une fenêtre de 1M ; un modèle à 200K comme l’ancien Claude Haiku 4.5 échouerait autour de l’étape 109, ce qui est une barrière accidentelle, pas un plan.

Dix-sept fois les étapes, environ 190 fois le coût. Avec la mise en cache des prompts (lectures de cache à environ 10 % du prix catalogue, écritures à environ 125 % chez Anthropic), la boucle Sonnet 5 devient 362 700 × 2,50 $ + 36 357 300 × 0,20 $ + 0,60 $ = environ 8,78 $. La mise en cache vaut la peine, comme le montre [la mise en cache des prompts pour les agents IA](/guides/prompt-caching-for-ai-agents), mais 22 fois une exécution saine reste une facture qui se remarque. DeepSeek V4.1 Flash, nom d’API deepseek-flash, a remplacé V4 Flash, que DeepSeek a retiré. Les lignes DeepSeek utilisent les tarifs de pointe ; les heures creuses coûtent moitié moins. Tarifs DeepSeek vérifiés le 2026-10-27 sur api-docs.deepseek.com.

1. max_tokens par appel. Dimensionnez-le pour l'étape, pas pour le plafond du modèle. Une étape d'appel d'outil a besoin de 512 à 2 048 tokens ; un rapport final peut nécessiter 4 000. Une seule réponse incontrôlée de 32 000 tokens sur Opus 5 coûte 32 000 × 25 $ = 0,80 $ à elle seule, et elle reste ensuite dans le contexte pour chaque étape ultérieure.

2. Nombre maximal d'étapes par exécution. Choisissez un nombre à partir de vos traces : le p95 des exécutions réussies plus une marge. Pour la plupart des boucles d'outils, cela se situe entre 15 et 30. Une exécution qui atteint le plafond doit échouer bruyamment, pas renvoyer silencieusement ce qu'elle avait.

3. Une condition d'arrêt explicite. Donnez au modèle un outil finish ou report et terminez la boucle lorsqu'il est appelé ou lorsque stop_reason est end_turn. Détectez également les progrès dégénérés : le même outil appelé avec les mêmes arguments deux fois de suite est une boucle, et l'exécution doit être interrompue.

4. Un budget en USD par exécution à partir de usage. Chaque réponse signale les tokens d'entrée, mis en cache et de sortie. Multipliez par les tarifs du modèle, accumulez et interrompez lorsque le total dépasse le plafond. C'est le seul garde-fou dont le seuil est dans l'unité qui vous importe réellement.

5. Un plafond de compte quotidien dans la console du fournisseur. Anthropic et OpenAI vous permettent de définir des limites de dépenses par espace de travail ou projet avec des alertes ; les budgets Google Cloud alertent et peuvent être configurés pour arrêter les dépenses. C'est la sécurité ultime pour le bug auquel vous n'avez pas encore pensé.

Les SDK clients réessayent les limites de débit et les erreurs serveur par défaut, généralement deux ou trois tentatives avec backoff exponentiel. Une requête rejetée n'est généralement pas facturée, mais une requête qui expire après le début de la génération l'est souvent, et une nouvelle tentative au niveau de l'application d'une étape renvoie tout le contexte à nouveau.

À l'étape 100 de la boucle de référence, le contexte est de 4 500 + 99 × 1 800 = 182 700 tokens. Une tentative sur Sonnet 5 sans cache coûte 182 700 × 2 $ = 0,37 $ ; trois tentatives coûtent 1,10 $ pour zéro progrès. Avec cache, chaque tentative coûte environ 0,04 $. Deux règles s'ensuivent : conservez le nombre de tentatives du SDK, ne l'enveloppez jamais dans votre propre boucle de tentatives, et si vous devez réessayer une exécution échouée depuis le début, comptez-la dans le même budget par exécution plutôt que d'en démarrer une nouvelle.

Ce runner Python pilote une boucle d'outils Claude et s'arrête lorsque le plafond en dollars ou le nombre d'étapes est atteint. La même structure fonctionne sur OpenAI avec responses.create et usage.input_tokens_details.cached_tokens.

from anthropic import Anthropic

PRICES = {"claude-sonnet-5": (2.0, 2.5, 0.2, 10.0)}  # $/1M : entrée, écriture cache, lecture cache, sortie

class BudgetedRunner:
    def __init__(self, model, system, tools, budget_usd, max_steps=25):
        self.client, self.model, self.system, self.tools = Anthropic(), model, system, tools
        self.budget, self.max_steps, self.spent = budget_usd, max_steps, 0.0

    def cost(self, u):
        i, w, r, o = PRICES[self.model]
        return (u.input_tokens * i + (u.cache_creation_input_tokens or 0) * w
                + (u.cache_read_input_tokens or 0) * r + u.output_tokens * o) / 1e6

    def run(self, messages, execute_tool):
        for step in range(1, self.max_steps + 1):
            resp = self.client.messages.create(model=self.model, max_tokens=1024,
                system=self.system, tools=self.tools, messages=messages)
            self.spent += self.cost(resp.usage)   # ex. 24 300 entrées × 2 $ + 300 sorties × 10 $ = 0,052 $
            if self.spent > self.budget:
                raise RuntimeError(f"budget ${self.budget} dépassé à l'étape {step} : ${self.spent:.3f}")
            messages.append({"role": "assistant", "content": resp.content})
            if resp.stop_reason != "tool_use":
                return resp, self.spent
            results = [{"type": "tool_result", "tool_use_id": b.id,
                        "content": execute_tool(b.name, b.input)}
                       for b in resp.content if b.type == "tool_use"]
            messages.append({"role": "user", "content": results})
        raise RuntimeError(f"limite d'étapes {self.max_steps} atteinte après ${self.spent:.3f}")

Définissez budget_usd à partir de vos traces : trois fois la médiane des exécutions réussies est un bon point de départ. Pour l'exécution de référence Sonnet 5, cela représente environ 1,20 $, que la boucle de 200 étapes atteindrait à l'étape 24, soit environ 73 $ avant que la console ne s'en aperçoive.

Un budget arrête une exécution. L'alerte vous indique que les exécutions ont commencé à en avoir besoin.

• Enregistrez le coût par exécution, pas par appel, avec le modèle, le nombre d'étapes et la raison d'arrêt
• Étiquetez chaque exécution avec la fonctionnalité ou le client qui l'a déclenchée, afin qu'un pic ait un propriétaire
• Alertez sur le coût p99 par exécution et sur la proportion d'exécutions qui atteignent la limite d'étapes ou le budget ; les deux qui augmentent ensemble signifient un nouveau mode de défaillance, pas une journée chargée
• Reconciliez chaque semaine avec le rapport d'utilisation du fournisseur, car un bug du runner qui sous-compte les tokens est lui-même une fuite

Si vous passez par OpenRouter, les limites de crédit par clé vous donnent un second plafond indépendant du fournisseur ; les compromis sont dans [OpenRouter vs API directe](/compare/openrouter-vs-direct-api).

Les garde-fous limitent les dégâts ; le choix du modèle définit la pente. Pour une boucle bien spécifiée, DeepSeek V4.1 Flash ($0.30 / $1.20) transforme le désastre de 200 étapes en une annoyance de $11 et Gemini 3.8 Flash ($0.75 / $3.75) en $28. D'après notre expérience, les deux sont fiables pour les appels d'outils structurés lorsque la tâche est claire, et l'article [Gemini agent API cost](/guides/gemini-agent-api-cost) couvre le côté Gemini.

Payez pour Claude Sonnet 5, GPT-5.4 ou un modèle phare lorsque la tâche est ambiguë ou la boucle longue, car ce sont les exécutions où un modèle bon marché est le plus susceptible de divaguer, et la divagation est ce que le tableau ci-dessus tarifie. Quel que soit votre choix, l'exécuteur ci-dessus fonctionne inchangé ; seule la ligne PRICES diffère. Tarifez votre propre trace dans le [calculateur](/calculator) et consultez [Claude agent API cost](/guides/claude-agent-api-cost) pour les champs d'utilisation par fournisseur.