Pourquoi le taux de cache hit des agents IA s'effondre : GPT, Claude et passerelles auditables

Guide sourcé sur les échecs de cache des agents tiers, le prompt caching de GPT et Claude, la mesure reproductible et la compensation publique de Modelflare.

Le cache d’un agent IA n’est pas une case à cocher. C’est un contrat de protocole, de routage et de comptabilité. Cet article explique pourquoi un agent tiers peut avoir un taux de succès très faible même lorsque le modèle amont prend en charge le prompt caching, comment GPT et Claude mesurent la réutilisation, et ce qu’une passerelle auditable doit garantir.

La décision en une phrase

Ne placez pas un agent de production sensible au cache derrière un agent ou une passerelle tierce qui ne montre pas l’usage natif, ne conserve pas un préfixe stable, ne maintient pas l’affinité modèle-route, ne publie pas le TTL et le dénominateur, et ne rapproche pas le résultat avec un registre durable. « Compatible avec le cache » décrit une fonction ; un taux éligible mesuré est un fait opérationnel.

Cela ne signifie pas que tous les agents tiers échouent. La documentation publique ne peut pas établir un pourcentage global pour un fournisseur sans corpus fixe, modèle fixe, fenêtre d’observation connue et preuve d’usage par requête. La conclusion plus précise est qu’une couche de traduction opaque crée plusieurs points de rupture indépendants et peut transformer un cache valide du fournisseur en chemin presque toujours froid. Pour une production dont l’économie dépend du cache, l’absence de preuve suffit à écarter ce chemin.

Définir le dénominateur avant de parler de pourcentage

Le fournisseur expose généralement trois compartiments. R désigne les tokens lus dans le cache, W les tokens écrits et U les tokens d’entrée traités sans réutilisation. Pour un préfixe éligible, le taux comparable est :

eligible_hit_rate = R / (R + W)

Pour toute l’entrée envoyée au modèle, la part réutilisée est :

input_reuse_share = R / (R + W + U)

Ces valeurs répondent à des questions différentes. Un tableau qui divise par toute l’entrée paraît faible lorsque l’agent envoie beaucoup de requêtes courtes et non éligibles. Un tableau limité au trafic éligible peut masquer le poids du suffixe dynamique dans le coût. Publiez les deux valeurs, la règle d’éligibilité et la fenêtre temporelle.

Le préfixe stable entre dans le cache réutilisable tandis que l’état variable de l’agent le contourne

La preuve se trouve dans les champs du fournisseur, pas dans un badge vert de l’interface de l’agent :

Signal Champ OpenAI Champ Claude Ce que cela prouve
Préfixe réutilisé input_tokens_details.cached_tokens cache_read_input_tokens Tokens servis par une entrée correspondante
Nouvelle entrée input_tokens_details.cache_write_tokens cache_creation_input_tokens Tokens utilisés pour créer ou prolonger une entrée
Entrée non réutilisée input_tokens - input_tokens_details.cached_tokens - input_tokens_details.cache_write_tokens (à dériver prudemment) input_tokens après le breakpoint Entrée hors préfixe ; les sémantiques diffèrent
Corrélation ID de requête, modèle et route ID de requête, modèle et route Quelle tentative du fournisseur a produit l’usage

Exemple synthétique, et non télémétrie de production Modelflare : R=720,000, W=80,000 et U=200,000 donnent un taux éligible de 720,000 / 800,000 = 90%, mais une part réutilisée sur toute l’entrée de 720,000 / 1,000,000 = 72%. Publier un seul nombre dissimule le dénominateur.

input_tokens_details.cache_write_tokens=0 ne prouve pas l’absence de cache : une lecture ne crée pas une nouvelle entrée. Si une réponse tierce omet le champ d’usage, ce n’est pas zéro ; c’est un échec d’observabilité à marquer non auditable.

Pourquoi le chemin de l’agent perd des succès malgré le support du modèle

La cause se trouve souvent entre l’application et le fournisseur. Voici les ruptures les plus courantes :

  • Les octets dynamiques arrivent trop tôt. Horodatage, ID de requête, utilisateur, expérience ou date courante variable modifient le préfixe avant les instructions réutilisables.
  • Les outils sont resérialisés. Ajouter, retirer, réordonner ou sérialiser de façon non déterministe un schéma d’outil modifie le préfixe exact ; même l’ordre des clés JSON peut provoquer un miss.
  • Le fallback change l’identité du cache. Répartir entre alias, régions, organisations ou identifiants ne partage pas une entrée universelle.
  • L’adaptateur supprime les contrôles natifs. Retirer cache_control, prompt_cache_key, la rétention ou les détails d’usage transforme la capacité en best effort invisible.
  • Le prompt est sous le seuil. Un tour court peut être valide sans être éligible au cache.
  • La fenêtre TTL est dépassée. Une entrée Claude de cinq minutes ou une rétention OpenAI propre au modèle peut expirer pendant une pause humaine.
  • Le préchauffage parallèle est en course. Les premières requêtes peuvent arriver avant que la première réponse rende l’entrée disponible.
  • L’historique est réécrit. Résumé, compactage, troncature ou autre sérialisation modifie le préfixe au lieu d’ajouter à la fin.

Trois formes de requête montrent comment lectures, écritures et entrée sans cache créent des dénominateurs différents

Aucun de ces échecs ne suppose une intention trompeuse. Ils découlent prévisiblement d’une passerelle qui traite la requête d’agent comme du texte libre sans préserver le contrat de cache du fournisseur. L’avertissement pratique est net : si l’agent ne peut pas montrer quel breakpoint a échoué, vous ne pouvez ni tarifer ni diagnostiquer correctement le trafic dépendant du cache.

GPT et Claude partagent l’idée, pas la sémantique

Les deux exigent un préfixe réutilisable identique, mais leurs contrôles et leur comptabilité diffèrent. Le tableau reprend les guides officiels vérifiés le 2026-08-25 ; noms, seuils et rétention peuvent évoluer.

Dimension Prompt caching OpenAI Prompt caching Claude
Unité réutilisable Préfixe complet du contexte rendu : instructions, outils, historique et éléments multimodaux Préfixe ordonné jusqu’à un breakpoint cache_control : outils, system, messages
Longueur minimale Le guide actuel indique 1 024 tokens visibles pour GPT-5.6+ et généralement 2 048 pour les anciens modèles Seuils propres au modèle, environ 512–4 096 tokens ; les prompts plus courts ne sont pas mis en cache
Contrôles Cache implicite ; breakpoints explicites et prompt_cache_key stable sur les modèles pris en charge Cache automatique de niveau supérieur ou breakpoints par bloc ; quatre maximum et regard sur 20 blocs
Rétention GPT-5.6+ prend en charge un TTL de 30 minutes ; les anciens modèles proposent des modes aux fenêtres typiques du fournisseur TTL par défaut de cinq minutes, renouvelé à l’usage ; une heure optionnelle avec écriture plus chère
Forme du prix Dans le guide GPT-5.6+ actuel, écriture 1,25× et lecture 0,1× de l’entrée de base Écriture cinq minutes 1,25×, une heure 2× ; lecture 0,1×
Preuve d’usage input_tokens_details.cached_tokens et, si présent, input_tokens_details.cache_write_tokens cache_read_input_tokens, cache_creation_input_tokens et input_tokens après le breakpoint
Invalidation fréquente Changement de modèle, outils ou réglages, débordement machine ou changement avant le breakpoint Changement du modèle, system, outils ou messages ; message précédent introuvable ou miss de préchauffage parallèle

OpenAI précise que les entrées résident sur des machines individuelles : prompt_cache_key aide au groupage et au routage, mais ne fixe pas une machine et ne garantit pas un hit. Claude documente la correspondance exacte, l’isolation par workspace et des diagnostics tels que tools_changed et messages_changed. Une passerelle qui masque ces différences ne peut pas en déduire honnêtement un taux unique.

Les multiplicateurs montrent l’enjeu. Pour le modèle OpenAI cité, une écriture suivie d’une lecture coûte environ 1.25 + 0.10 = 1.35× l’unité d’entrée sans cache ; dix requêtes entièrement réutilisées coûtent 1.25 + 9×0.10 = 2.15× plutôt que 10×. Ce sont des calculs illustratifs officiels, pas une facture Modelflare ni une promesse pour tous les modèles.

La taxe d’adaptateur se mesure

Utilisez une matrice d’échec, pas une capture d’écran. Fixez prompt, modèle, identifiants et débit ; changez une seule variable et conservez l’objet usage natif.

Changement contrôlé Signal attendu Ce qu’un agent opaque peut cacher Lecture pour la mise en production
Ajouter uniquement le tour utilisateur R augmente après le premier W Historique réécrit ou nouvelle route Préfixe conservé
Ajouter un horodatage au system prompt R tombe à zéro ou un nouveau W apparaît Octets modifiés Le préfixe dynamique casse le cache
Réordonner une propriété d’outil tools_changed ou nouvelle écriture Comportement du sérialiseur Schéma déterministe requis
Répartir le trafic entre alias ou machines R plus faible et variable Route et clé choisies Affinité absente
Attendre au-delà du TTL Nouvelle écriture après expiration Heure d’expiration et mode de rétention Mesurer les pauses humaines séparément
Envoyer deux premières requêtes identiques en parallèle L’une ou les deux peuvent écrire Course et ordre des tentatives Un burst froid ne mesure pas la capacité

Conservez ID de requête, mode de streaming, heure du premier événement, modèle exact, route choisie, champs de cache et horodatage UTC. Masquez prompts, clés et contenu client. Si la passerelle ne renvoie qu’un total d’entrée normalisé, marquez l’essai non auditable ; les dimensions manquantes ne sont pas des zéros inventés.

Un relevé d’audit reproductible

Voici un petit format synthétique. L’enveloppe est neutre et usage conserve les champs natifs. Ce n’est pas un benchmark.

{"request_id":"demo-001","timestamp":"2026-08-25T02:00:00Z","model":"MODEL_ID","route":"route-a","stream":true,"usage":{"input_tokens":1000000,"input_tokens_details":{"cached_tokens":0,"cache_write_tokens":1000000}}}
{"request_id":"demo-002","timestamp":"2026-08-25T02:00:03Z","model":"MODEL_ID","route":"route-a","stream":true,"usage":{"input_tokens":1000000,"input_tokens_details":{"cached_tokens":720000,"cache_write_tokens":80000}}}

Exécutez au moins cinq phases : préchauffage séquentiel, conversation en ajout seul, mutation dynamique du système, mutation de l’ordre des outils et rejeu après une pause TTL. Gardez les champs natifs de lecture/écriture de chaque fournisseur et comparez R/(R+W) et R/(R+W+U) par phase, route, modèle et jour UTC. Un nombre agrégé ne suffit pas pour approuver un agent en production.

Ce que Modelflare garantit, et ce qu’il ne garantit pas

La page publique de statut de Modelflare décrit actuellement OpenAI Cache Hit Rate Guarantee. Pour les requêtes éligibles qui satisfont les exigences de cache OpenAI et forment un cache valide, le taux quotidien est calculé par jour calendaire UTC. S’il est inférieur au niveau applicable, la différence est compensée et visible dans Dashboard → Token Usage Analysis. Les niveaux publics actuels sont 65%, 75% et 85%.

Trois niveaux publics de garantie montent de 65 à 85 pour cent

La limite est volontaire :

  • La garantie couvre le trafic OpenAI éligible et valide, pas une requête courte ou constamment changeante qui ne qualifie jamais.
  • Elle ne transforme pas un modèle, un schéma d’outil, une route ou un TTL changeant en préfixe réutilisable.
  • Le calcul est quotidien en UTC et le crédit passe par la surface de compte documentée ; il ne promet pas un hit pour chaque requête.
  • Les preuves natives et le calcul d’éligibilité restent obligatoires. Un dénominateur explicite rend la compensation vérifiable.

C’est la différence entre une promesse de service auditable et un slogan d’agent : la première nomme la population, la fenêtre, le seuil et la destination du crédit.

L’avantage tarifaire et la légitimité opérationnelle sont deux preuves

La page de prix actuelle affiche aussi un ratio promotionnel de 0,015 pour la première recharge dans la campagne/groupe concerné, avec le minimum et les conditions publiés. C’est un avantage tarifaire, pas la garantie de cache. Vérifiez en direct la portée des modèles et les règles de règlement.

Les documents publics de confiance et juridiques identifient Havenbyte LLC comme opérateur et décrivent une exploitation basée aux États-Unis. Ils citent Stripe comme processeur pour les paiements, factures, remboursements et contrôles antifraude. Ce sont des signaux de responsabilité et de garde, pas une affirmation sur un État d’enregistrement ou une certification précise.

Recommandation pour les agents de production

Ne choisissez un agent tiers que s’il passe cette liste :

  • Il relaie les contrôles natifs et renvoie les lectures et écritures natives.
  • Il conserve les octets du préfixe stable d’instructions et d’outils, puis ajoute l’état dynamique.
  • Il expose modèle, route, frontière organisation/région, mode TTL et ID de requête.
  • Il enregistre séparément le préchauffage séquentiel et parallèle.
  • Il définit par écrit trafic éligible, dénominateur, fenêtre UTC, seuil et compensation.
  • Il permet d’exporter les preuves par requête sans exposer clés ni contenu client.

Si une réponse est « non », n’utilisez pas ce chemin pour un workload dont l’économie dépend de la réutilisation. Testez la route directe du fournisseur ou choisissez une passerelle auditable comme Modelflare avec le même corpus. Voir aussi routage fiable des API IA, suivi des coûts API IA, prix et confiance.

Sources et date de vérification

Ces sources primaires ont été vérifiées le 2026-08-25. Elles décrivent les contrats des fournisseurs et la politique publique actuelle de Modelflare ; elles ne prouvent pas un taux universel pour un agent tiers non nommé.

FAQ : Un taux tiers faible signifie-t-il toujours une fraude ?

Non. Prompts courts, préfixes variables, routes dispersées, expiration TTL ou champs absents peuvent l’expliquer. Le constat correct est « non reproductible » ou « non auditable » jusqu’à ce qu’un test contrôlé montre la cause.

FAQ : Peut-on comparer Claude et GPT avec un seul nombre ?

Seulement après normalisation du dénominateur et conservation des champs natifs. Comparez le même corpus et la même phase, pas un total de tableau mélangé.

FAQ : La compensation supprime-t-elle le besoin d’un préfixe stable ?

Non. La compensation limite le risque financier du trafic OpenAI éligible ; elle ne rend pas réutilisable une requête non éligible et ne répare pas un agent qui réécrit le préfixe.