BroadRouter
Commencer

Coût d’une exécution d’agent de code IA : étapes, contexte, cache

Par l’équipe BroadNet Inference · 7 min de lecture · Publié

Un agent renvoie tout son contexte à chaque étape : l’entrée croît donc avec le carré du nombre d’étapes, et 60 étapes coûtent environ 3,5 fois l’entrée de 30. Le cache décide de l’essentiel de la facture ; avec un historique en ajout seul, plus de 90 % de l’entrée peut être facturée au tarif cache. Multipliez le coût par exécution par le nombre mensuel d’exécutions et comparez à une session au forfait.

Un agent de code ne paie pas à la tâche. Il paie à l’étape, et chaque étape renvoie toute la conversation jusque-là. Le coût d’une exécution dépend donc bien plus du nombre d’étapes, et de la part du contexte mise en cache, que du prix par token. Cet article construit le coût d’une exécution à partir de ces éléments, chiffres à l’appui, et montre quand une session au forfait l’emporte sur le paiement au token.

Pour savoir d’où viennent les tokens de chaque appel (schémas d’outils, lectures de fichiers, historique), voir où partent les tokens d’une boucle d’agent. Cet article porte sur l’arithmétique d’une exécution complète.

Comment le contexte grossit-il pendant une exécution d’agent ?

Chaque appel contient :

  • un contexte de base envoyé à chaque appel : prompt système, définitions d’outils, fichiers de règles, carte du dépôt ;
  • tout ce qu’ont ajouté les étapes précédentes : les réponses et appels d’outils du modèle, le contenu des fichiers et la sortie des commandes ;
  • la nouvelle instruction ou le nouveau résultat d’outil.

Appelons B ce contexte de base et g les tokens ajoutés à chaque étape. L’étape 1 envoie B. L’étape 2 envoie B + g. L’étape n envoie B + (n − 1) × g. En additionnant, une exécution de n étapes envoie :

Entrée totale = n × B + g × n × (n − 1) ÷ 2

Le second terme croît avec le carré du nombre d’étapes. C’est pourquoi les longues exécutions surprennent : la dernière étape d’une exécution de 60 étapes est bien plus grosse que la première, et chaque étape intermédiaire repaie toutes les précédentes.

À quoi ressemble une exécution chiffrée ?

Prenons un agent avec un contexte de base de 15 000 tokens (prompt système, une douzaine d’outils et une carte du dépôt). Chaque étape ajoute 3 000 tokens : un fichier ou un log de test, plus la réponse du modèle lui-même. Chaque étape écrit 800 tokens de sortie, raisonnement compris.

Étapes Entrée totale Sortie Plus gros appel
10 285 000 8 000 42 000
30 1 755 000 24 000 102 000
60 6 210 000 48 000 192 000

Passer de 30 à 60 étapes double le travail, mais multiplie l’entrée par environ 3,5. La sortie, elle, ne fait que doubler. Dans ces exécutions, l’entrée représente de 36 à 130 fois la sortie : c’est pourquoi le prix d’entrée, et celui de l’entrée en cache, comptent le plus pour les agents.

Le plus gros appel doit aussi tenir dans la fenêtre de contexte. 192 000 tokens tiennent dans DeepSeek V4.1 Flash et GLM 5.3 (1 048 576 tokens chacun) et dans Qwen3.8 27B (262 144). Ils ne tiennent pas dans Gemma 4 VL 26B (32 768) : dans cet exemple, le septième appel est déjà trop gros.

Dans quelle mesure le cache change-t-il la facture ?

Les fournisseurs facturent un préfixe de prompt répété au tarif réduit de l’entrée en cache. Un agent qui ne fait qu’ajouter à son historique envoie à chaque fois le même préfixe plus un peu plus. Dans le meilleur cas, seuls les tokens ajoutés depuis le dernier appel sont nouveaux :

Entrée nouvelle (meilleur cas) = B + (n − 1) × g

Tout le reste est un hit de cache. La part de l’entrée en cache augmente à mesure que l’exécution s’allonge :

Étapes Entrée nouvelle, meilleur cas Part en cache
10 42 000 85 %
30 102 000 94 %
60 192 000 97 %

Les vrais agents atteignent rarement le meilleur cas : il est donc utile de chiffrer trois scénarios. Aux prix de BroadNet pour DeepSeek V4.1 Flash ($0.175 en entrée, $0.0055 en cache, $0.52 en sortie par million de tokens, publiés le 2026-11-14), voici le coût de chaque exécution par rapport au meilleur cas à 30 étapes :

Étapes Cache au meilleur cas 80 % en cache Sans cache
10 0,33× 0,39× 1,37×
30 1× 2,07× 8,11×
60 2,33× 6,84× 28,2×

Deux choses ressortent. Sans cache, une exécution de 60 étapes coûte 28 fois une exécution de 30 étapes bien mise en cache. Et le cache compte d’autant plus que l’exécution s’allonge. Dans le meilleur cas à 30 étapes, la sortie représente environ un tiers du coût, l’entrée nouvelle moins de la moitié et l’entrée en cache moins d’un quart : une fois le cache en place, la prochaine économie se trouve donc du côté de la sortie.

Le cache ne s’active pas d’un clic. Il dépend du fournisseur, qui doit conserver le préfixe, et de votre agent, qui ne doit pas le modifier. Le guide d’OpenAI décrit une correspondance exacte de préfixe avec une longueur minimale mise en cache. L’API de DeepSeek stocke des unités de cache à la fin de l’entrée et de la sortie de chaque requête, si bien qu’une requête suivante qui prolonge la précédente peut faire un hit. La page des tarifs de BroadNet indique que l’entrée en cache ne demande aucune configuration, et sa documentation signale les hits dans usage.prompt_tokens_details.cached_tokens quand le modèle les fournit. Le catalogue de modèles de BroadNet range DeepSeek V4.1 Flash parmi les « models we never ran on our hardware » (traduction : « modèles que nous n’avons jamais fait tourner sur notre matériel »), et ses Conditions (§7.3) couvrent le modèle « when partner-hosted » (traduction : « lorsqu’il est hébergé par un partenaire ») : chez BroadNet, il est donc servi par un partenaire. Mesurez votre taux de hits plutôt que de supposer les chiffres de DeepSeek. Écrivez le préfixe pour qu’il puisse être mis en cache : structurer un prompt pour le cache.

Comment estimer votre propre exécution ?

Ce script lit les prix actuels dans le pricing.json public de BroadNet, donc il n’est jamais périmé, et affiche les totaux de tokens et le coût par exécution pour chaque scénario de cache :

import json, urllib.request

PRICES = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
m = next(x for x in PRICES["models"] if x["id"] == "broadnet/deepseek-v4.1-flash")
p_in, p_cached, p_out = m["input_per_m"], m["cached_input_per_m"], m["output_per_m"]

def run_tokens(steps, base=15_000, growth=3_000, out_per_step=800, cache_rate=None):
    total_in = steps * base + growth * steps * (steps - 1) // 2
    if cache_rate is None:                      # best case: only new tokens miss
        new_in = base + (steps - 1) * growth
    else:
        new_in = round(total_in * (1 - cache_rate))
    return total_in, new_in, steps * out_per_step

def run_cost(total_in, new_in, out):
    return ((new_in * p_in) + (total_in - new_in) * p_cached + out * p_out) / 1e6

for steps in (10, 30, 60):
    for label, rate in (("best", None), ("80%", 0.8), ("none", 0.0)):
        t, n, o = run_tokens(steps, cache_rate=rate)
        print(f"{steps:>3} steps  cache {label:>4}  input {t:>9,}  new {n:>9,}  "
              f"output {o:>6,}  cost/run {run_cost(t, n, o):.4f} USD")

Remplacez les valeurs par défaut par vos propres chiffres. Ne les devinez pas : relevez-les sur une vraie exécution.

  1. Journalisez prompt_tokens, prompt_tokens_details.cached_tokens et completion_tokens pour chaque appel, comme dans l’article sur le budget de tokens d’un agent.
  2. B est le prompt_tokens du premier appel. g est l’augmentation moyenne de prompt_tokens d’un appel au suivant.
  3. La sortie par étape est la moyenne de completion_tokens. Elle inclut les tokens de raisonnement, facturés comme de la sortie.
  4. Votre taux de cache réel est la somme des cached_tokens divisée par la somme des prompt_tokens.

L’estimateur gratuit du coût d’une exécution d’agent fait le même calcul dans votre navigateur : vous pouvez essayer d’autres nombres d’étapes, taux de croissance et taux de cache sans code.

Qu’est-ce qui fait dépasser l’estimation ?

  • Les retries. Un appel d’outil échoué ou un retry après un 429 est un appel de plus avec tout le contexte. Comptez-les comme des étapes.
  • Un préfixe modifié. Un horodatage dans le prompt système, des outils listés dans un autre ordre ou un fichier de règles modifié en cours d’exécution retransforment l’entrée en cache en entrée nouvelle à partir de la modification.
  • Le compactage. Résumer l’historique réduit le contexte, ce qui diminue l’entrée ultérieure, mais le nouvel historique n’a jamais été mis en cache : l’appel suivant paie le plein tarif d’entrée. Compactez rarement et par grandes étapes ; la gestion du contexte des agents de longue durée explique quand.
  • Une sortie d’outil volumineuse. Un log de test de 20 000 lignes ajouté à l’étape 5 est transporté à chaque étape suivante. Dans la formule, il ajoute 20 000 × (étapes restantes) tokens d’entrée.
  • L’effort de raisonnement. Un effort élevé peut multiplier la sortie par étape. Réglez reasoning_effort sur low pour les modifications de routine.
  • L’errance. Un agent qui met 60 étapes pour une tâche de 30 paie le carré, pas le double. Un plafond d’étapes est un plafond de coût. Dix façons de réduire le coût d’un agent de code passe en revue les leviers.

Quand une session au forfait l’emporte-t-elle sur la facturation au token ?

Transformez le coût par exécution en chiffre mensuel : coût mensuel = coût par exécution × exécutions par mois. Comparez-le ensuite à un forfait. Chez BroadNet, les forfaits couvrent DeepSeek V4.1 Flash sans compteur de tokens : Full Moon coûte $60 par mois, Orbit $15 par semaine et Meteor $1 de l’heure, chaque fois par session.

Exécutions par mois pour atteindre le seuil de rentabilité = prix du forfait ÷ coût par exécution.

Deux éléments rendent cette comparaison moins simple qu’il n’y paraît :

  1. Votre taux de cache détermine le côté au token. Avec un taux élevé, la facturation au token sur Flash est bon marché et il faut beaucoup d’exécutions pour dépasser $60. Avec un taux médiocre, vous le dépassez vite. L’article sur le forfait exprime le seuil de rentabilité en volume mensuel : environ 917 millions de tokens d’entrée et 46 millions de tokens de sortie avec 80 % en cache (le calcul du seuil de rentabilité).
  2. Le temps fixe le plafond du côté forfait. Une session traite une requête à la fois. Si un appel prend en moyenne 20 secondes (prefill, environ 800 tokens de sortie à environ 100 tokens par seconde, plus le temps des outils), une exécution de 30 étapes prend environ 10 minutes. Une session tient alors au plus environ six exécutions par heure. Davantage d’agents en parallèle demandent davantage de sessions.

Pour de courtes rafales, Meteor fonctionne de la même façon à plus petite échelle : si six exécutions tiennent dans une heure, chacune coûte $1 ÷ 6. Comparez avec le coût au token d’une exécution donné par le script. Pour tester vos propres volumes, utilisez le calculateur forfait ou paiement au token.

Votre profil En général moins cher
Quelques courtes exécutions par jour Au token
Longues exécutions avec un cache médiocre Session au forfait
Agents actifs la majeure partie de la journée de travail Session au forfait
Plusieurs agents en parallèle, toute la journée Une session au forfait par agent
Besoin de l’appel d’outils natif chez BroadNet Au token sur GLM 5.3 ou Qwen3.8 27B

La place de BroadNet Inference

BroadNet indique les tokens en cache et les tokens de raisonnement dans le bloc usage : vous pouvez donc mesurer chacun des chiffres ci-dessus sur vos propres exécutions. DeepSeek V4.1 Flash a un prix d’entrée en cache bas et un contexte de 1 048 576 tokens, et les forfaits illimités suppriment son compteur de tokens ; fonctionnement des sessions.

Vérifiez d’abord une limite. La documentation de BroadNet n’indique l’appel d’outils que pour GLM 5.3 et Qwen3.8 27B, et aucun des deux n’est inclus dans un forfait. Les agents qui éditent via du texte, comme Aider, n’ont pas besoin d’appels d’outils natifs. Si le vôtre en a besoin, testez DeepSeek V4.1 Flash avec votre agent avant d’acheter un forfait, ou budgétez GLM ou Qwen au token. Et si votre agent ne tourne que de temps en temps, le paiement au token coûtera en général moins cher que n’importe quel forfait.

Questions fréquentes

Combien coûte une exécution d’agent de code IA ?

Comptez les tokens, puis appliquez les prix. Dans l’exemple de cet article, une exécution de 30 étapes avec un contexte de base de 15 000 tokens et 3 000 tokens ajoutés par étape envoie 1 755 000 tokens d’entrée et 24 000 tokens de sortie. Le coût dépend surtout de la part de l’entrée facturée au tarif cache.

Pourquoi une exécution d’agent plus longue coûte-t-elle disproportionnellement plus ?

Chaque étape renvoie tout ce qui précède. L’entrée par étape croît de façon linéaire, donc le total sur une exécution croît avec le carré du nombre d’étapes. Passer de 30 à 60 étapes multiplie l’entrée par environ 3,5 dans l’exemple chiffré.

Quel taux de hits de cache attendre d’un agent de code ?

Cela dépend de l’agent et du fournisseur. Avec un historique strictement en ajout seul, seuls les tokens les plus récents manquent le cache, ce qui a donné de 85 % à 97 % dans nos exemples. Un historique modifié, un horodatage dans le prompt système et de longues pauses le font baisser. Mesurez-le avec prompt_tokens_details.cached_tokens.

Quand une session au forfait coûte-t-elle moins cher que la facturation au token pour un agent ?

Quand coût par exécution × exécutions par mois dépasse le prix du forfait. Chez BroadNet, Full Moon coûte $60 par mois et par session pour DeepSeek V4.1 Flash. Un usage léger ou occasionnel revient en général moins cher au token.

Les tokens de raisonnement changent-ils l’estimation ?

Oui. Ils sont facturés comme de la sortie, et la sortie coûte plus cher par token que l’entrée. Intégrez le raisonnement mesuré dans la sortie par étape. Chez BroadNet, completion_tokens_details.reasoning_tokens l’indique quand le modèle le fournit.

Lire en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity