---
title: "Coût d’une exécution d’agent IA : étapes et cache | BroadRouter"
description: "Pourquoi chaque étape d’un agent de code coûte plus cher à mesure qu’il avance, l’effet du cache sur le total et quand une session au forfait gagne. Calcul détaillé."
url: https://broadrouter.com/fr/blog/ai-coding-agent-run-cost/
lang: fr
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/ai-coding-agent-run-cost/) (mis à jour le 2026-11-15).

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

Par l’équipe BroadNet Inference · 7 min de lecture · Publié 2026-11-15

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.

## À retenir

-   L’entrée totale d’une exécution vaut étapes × contexte de base + croissance par étape × étapes × (étapes − 1) ÷ 2. Le nombre d’étapes pèse plus que tout autre paramètre.
-   Avec un historique en ajout seul, seuls les tokens ajoutés depuis le dernier appel sont nouveaux. Dans l’exemple chiffré, 94 % de l’entrée d’une exécution de 30 étapes reste ainsi en cache.
-   Aux prix publiés par BroadNet pour DeepSeek V4.1 Flash, la même exécution de 30 étapes coûte environ 8 fois plus sans cache qu’avec un cache dans le meilleur cas.
-   Compacter ou modifier l’historique ancien réinitialise le cache. Faites-le rarement et par grandes étapes.
-   Une session au forfait l’emporte quand exécutions mensuelles × coût par exécution dépasse le prix du forfait. Une session traite une requête à la fois : la durée d’une exécution plafonne donc le nombre d’exécutions par mois.

**Sur cette page**

1.  Comment le contexte grossit-il pendant une exécution d’agent ?
2.  À quoi ressemble une exécution chiffrée ?
3.  Dans quelle mesure le cache change-t-il la facture ?
4.  Comment estimer votre propre exécution ?
5.  Qu’est-ce qui fait dépasser l’estimation ?
6.  Quand une session au forfait l’emporte-t-elle sur la facturation au token ?
7.  La place de BroadNet Inference

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](https://broadrouter.com/fr/blog/agent-token-budget/). 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](https://broadrouter.com/fr/glossary/context-window/). 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](https://broadrouter.com/fr/glossary/cached-input-tokens/). 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](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-ai-coding-agent-run-cost&utm_content=body) 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](https://broadrouter.com/fr/blog/prompt-structure-for-caching/).

## Comment estimer votre propre exécution ?

Ce script lit les prix actuels dans le [pricing.json](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-ai-coding-agent-run-cost&utm_content=body) 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 :

```python
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](https://broadrouter.com/fr/blog/agent-token-budget/).
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](https://broadrouter.com/fr/glossary/reasoning-tokens/), 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](https://broadrouter.com/tools/agent-run-cost-estimator/) 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](https://broadrouter.com/fr/blog/long-running-agent-context-management/) 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](https://broadrouter.com/fr/blog/cut-coding-agent-llm-costs/) 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é](https://broadrouter.com/fr/blog/flat-rate-vs-pay-per-token-llm-api/)).
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](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/).

| 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](https://broadrouter.com/fr/guides/unlimited-llm-api-sessions/).

Vérifiez d’abord une limite. La documentation de BroadNet n’indique l’appel d’outils que pour [GLM 5.3](https://broadrouter.com/fr/models/glm-5.3/) et [Qwen3.8 27B](https://broadrouter.com/fr/models/qwen3.8-27b/), et aucun des deux n’est inclus dans un forfait. Les agents qui éditent via du texte, comme [Aider](https://broadrouter.com/fr/guides/aider-unlimited-deepseek/), 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.

Outils gratuits sur ce sujet (en anglais)

-   [Agent run cost estimator](https://broadrouter.com/tools/agent-run-cost-estimator/) Context growth per step, total tokens and cost of one agent run, with a DeepSeek session comparison.
-   [LLM batch job planner](https://broadrouter.com/tools/llm-batch-job-planner/) Run time, binding limit, cost per model and the flat sessions needed to finish a big job by a deadline.
-   [Flat-rate vs per-token LLM cost calculator](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/) Break-even between an unlimited plan and paying per token, per agent.
-   [LLM rate limit and concurrency calculator](https://broadrouter.com/tools/llm-rate-limit-calculator/) Which limit binds first: RPM, TPM or concurrency, with Little's law.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

[Token](https://broadrouter.com/fr/glossary/token/)

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[Tokens d’entrée en cache (cached input tokens)](https://broadrouter.com/fr/glossary/cached-input-tokens/)

Les tokens d’entrée en cache sont des tokens de prompt qu’un fournisseur de LLM a traités récemment et peut réutiliser depuis un cache au lieu de les recalculer, en général un préfixe répété comme un prompt système ou un document. Les fournisseurs les facturent moins cher que les nouveaux tokens d’entrée.

[Tokens d’entrée et de sortie](https://broadrouter.com/fr/glossary/input-and-output-tokens/)

Les tokens d’entrée sont les tokens qu’un modèle de langage lit dans une requête, dont le prompt système, l’historique de conversation, les définitions d’outils et les images. Les tokens de sortie sont ceux qu’il génère en réponse, raisonnement compris. Les API LLM les facturent généralement séparément, et la sortie coûte en général plus cher.

[Prompt système (system prompt)](https://broadrouter.com/fr/glossary/system-prompt/)

Le prompt système est le texte d’instructions qu’une application envoie à un modèle de langage avant la conversation, généralement sous forme de message au rôle system ou developer. Il fixe le rôle, les règles, le ton et le format de sortie du modèle, qui est censé le suivre même face à des messages contradictoires de l’utilisateur.

[Tokens de raisonnement (reasoning tokens)](https://broadrouter.com/fr/glossary/reasoning-tokens/)

Les tokens de raisonnement sont les tokens qu’un modèle de raisonnement génère pour résoudre un problème avant d’écrire sa réponse visible. Ils sont généralement facturés comme des tokens de sortie, comptent dans la limite de sortie et dans la fenêtre de contexte, et peuvent être masqués ou résumés par l’API.

[Agent de code IA (AI coding agent)](https://broadrouter.com/fr/glossary/coding-agent/)

Un agent de code IA est un outil logiciel dans lequel un modèle de langage travaille en boucle sur une base de code : il lit des fichiers, les modifie, lance des commandes comme les tests, lit la sortie et décide de l’étape suivante jusqu’à ce que la tâche soit terminée ou qu’une limite soit atteinte.

[Agent IA (AI agent)](https://broadrouter.com/fr/glossary/agent/)

Un agent IA est un système dans lequel un modèle de langage dirige lui-même ses étapes vers un objectif : il décide quels outils appeler, lit les résultats et recommence jusqu’à produire une réponse finale ou atteindre une limite. Un script fixe qui appelle un modèle à des moments prévus s’appelle plutôt un workflow.

## 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 ensuite

-   [Budget de tokens d’un agent : où partent les tokens d’une boucle](https://broadrouter.com/fr/blog/agent-token-budget/)
-   [Réduire le coût LLM d’un agent de code : 10 leviers chiffrés](https://broadrouter.com/fr/blog/cut-coding-agent-llm-costs/)
-   [API LLM : forfait ou paiement au token ? Le calcul de rentabilité](https://broadrouter.com/fr/blog/flat-rate-vs-pay-per-token-llm-api/)
-   [Tokens d’entrée en cache : réduire la facture d’une API LLM](https://broadrouter.com/fr/blog/cached-input-tokens-explained/)
-   [Gérer le contexte des agents longue durée avec une fenêtre de 1M](https://broadrouter.com/fr/blog/long-running-agent-context-management/)
-   [Claude Code et modèles ouverts : proxys, endpoints natifs, limites](https://broadrouter.com/fr/blog/claude-code-with-openai-compatible-models/)
-   [OpenClaw et Hermes Agent sur un modèle bon marché : config et coûts](https://broadrouter.com/fr/blog/openclaw-hermes-agent-cheap-model/)
-   [Guide : Comment fonctionnent les forfaits API LLM illimités pour agents](https://broadrouter.com/fr/guides/unlimited-llm-api-sessions/)
-   [Guide : Faire tourner Aider sur DeepSeek V4.1 Flash en illimité](https://broadrouter.com/fr/guides/aider-unlimited-deepseek/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-ai-coding-agent-run-cost&utm_content=page-cta) ·

**Sources**

-   [Référence de l’API de BroadNet Inference : champs usage, cached\_tokens, le raisonnement compte dans max\_tokens, limites (vérifiée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [Page des tarifs et pricing.json de BroadNet Inference, prix mis à jour le 2026-11-14 (vérifiés le 2026-11-15) (en anglais)](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [Page des forfaits de BroadNet Inference : une requête à la fois par session, sans compteur de tokens (vérifiée le 2026-11-15) (en anglais)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-ai-coding-agent-run-cost&utm_content=sources)
-   [Guide du prompt caching d’OpenAI : correspondance de préfixe et longueur minimale mise en cache (vérifié le 2026-11-15)](https://developers.openai.com/api/docs/guides/prompt-caching)
-   [Documentation de l’API DeepSeek, context caching : unités de cache aux limites des requêtes (vérifiée le 2026-11-15)](https://api-docs.deepseek.com/guides/kv_cache)
