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.
- Journalisez
prompt_tokens,prompt_tokens_details.cached_tokensetcompletion_tokenspour chaque appel, comme dans l’article sur le budget de tokens d’un agent. - B est le
prompt_tokensdu premier appel. g est l’augmentation moyenne deprompt_tokensd’un appel au suivant. - La sortie par étape est la moyenne de
completion_tokens. Elle inclut les tokens de raisonnement, facturés comme de la sortie. - Votre taux de cache réel est la somme des
cached_tokensdivisée par la somme desprompt_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_effortsurlowpour 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 :
- 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é).
- 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.
