← blog.bulgarelli.dev · Papers

Le (vrai) coût d'un outil de récupération structurelle de code

Brice Bulgarelli · 11 novembre 2026 · code, données et transcripts : seam-public@study-structural-limits-v1 · version accessible : l'article

Version française de STUDY_STRUCTURAL_LIMITS.md, qui fait référence et dont chaque chiffre est recalculé par bench/replay-ceiling/verify_independent.py.

Résumé

Compresser la sortie des outils agentiques n'est pas la solution à la réduction de coûts. Cette étude pose la question inverse : est-ce qu'injecter un payload structurel de bonne qualité permettrait de faciliter le traitement par le LLM, à la fois en termes de rapidité mais également de coût ? Cette étude montre que non.

À l'aide d'un oracle de replay (outil "parfait" permettant de rejouer la sortie d'un outil structurel sans latence ni mauvais chemin), j'ai pu volontairement nourrir les agents du chemin "idéal" à prendre pour retrouver les liens entre les parties de code, le tout en 6 "tours" d'appel à l'outil (le dernier affichant DONE).

Exemple :

$ call-flow --step 1
=== step 1 of 5 ===
# Locate route: /admin/realms
147 route(s) matched; 1 with BOTH sides resolved - the crossing itself, [...]

- /admin/realms
    serves   integration/admin-client/src/main/java/org/keycloak/admin/client/resource/RealmsResource.java:35
    serves   services/src/main/java/org/keycloak/services/resources/admin/AdminRoot.java:232
    fetches  js/libs/keycloak-admin-client/src/resources/realms.ts:409
[...]
--- next: call-flow --step 2 ---

$ call-flow --step 2
=== step 2 of 5 ===
# Agent map - the region to read instead of a grep loop
[...]
  Realms (js/libs/keycloak-admin-client/src/resources/realms.ts:22) - PINNED CENTER
      22> export class Realms extends Resource {
[... 27 Ko ...]
--- next: call-flow --step 3 ---

$ call-flow --step 3
=== step 3 of 5 ===
# Coupling of RealmAdminResource (cross-stack data boundary)
anchor: RealmAdminResource | shape: coupling | shared keys: 40 | counterpart sites: 57
[...]

$ call-flow --step 4
=== step 4 of 5 ===
# Locate: 6 name(s)
## getRealm - 25 definition(s) of 207 - narrow with `--in <path-prefix>`
[...]

$ call-flow --step 5
=== step 5 of 5 ===
# Locate: 2 name(s)
## updateRealm - 1 definition(s)
- server-spi-private/src/main/java/org/keycloak/models/utils/RepresentationToModel.java:285#updateRealm
[...]

$ call-flow --step 6
DONE - no further steps. You have everything the trace can give you.

Avec une réponse prouvée complète, l'agent fait 14,8 appels supplémentaires (dont 4,6 refusés) après le marqueur DONE, ce qui représente 52 % du coût du run, et il termine à 21,8 tours du modèle contre 23,4 pour le contrôle. La conclusion est que, sans les appels refusés, son contexte total vaut 1,003x celui du contrôle malgré l'accès à la réponse complète à environ un tiers du contexte.

La réponse des 6 appels de l'oracle a été poussée à la vérification par l'agent, et cette dernière a lu à elle seule près des deux tiers du contexte du contrôle.

=> En termes de coûts, l'outil (Seam) livré tel quel coûte 1,36x (ajusté) alors qu'il réduit les appels d'outils de 36 %.

On en déduit avant tout que la vérification après la réponse ne dépend pas de la qualité de la réponse, donc la réduction de tours sur laquelle repose tout l'échange n'arrive pas, même avec un outil idéal. Et cela est également valide sur un second modèle, Sonnet (sur 3 rounds, avec un plancher plus petit). C'est donc qu'il y a une notion de "plancher de vérification" : le plancher est ce besoin de vérifier par le modèle. On déduit également que la prime d'écriture est la totalité du surcoût restant : le volume d'informations à ingurgiter provenant de l'oracle pèse dans les calculs de coût, car le payload est écrit dans le cache d'un bloc, tôt, à 20 fois le prix d'une lecture, et comme l'outil réduit justement le nombre de tours, il en reste peu pour amortir cette écriture, là où grep écrit de petits morceaux au fil du run.

À l'inverse, et en tant qu'ouverture : un oracle réduit à sa réponse seule exacte (et non un simple "rejeu" des possibilités d'un outil comme Seam) coûte 0,45x grep et est moins cher dans les 5 rounds, mais l'agent vérifie encore une dizaine de fois après une réponse complète obtenue en un seul appel. De là à savoir si cet outil idéal, nécessitant un jugement sémantique, est réalisable, c'est là où je m'arrêterai...


Introduction

Une étude récente (arXiv 2607.12161) a montré qu'une réduction du nombre de tokens n'implique pas forcément une réduction des coûts.

Ici, nous avons testé une approche différente, avec à l'appui un outil nommé "Seam", issu d'un projet qui avait pour objectif d'optimiser les coûts et les performances d'un agent lors du traçage d'un "flow" de code.

Une fois Seam fabriqué, je me suis rendu compte que, malgré un nombre d'appels d'outils divisé par 2,7 en moyenne sur une première mesure (6 rounds sur Keycloak), et malgré moins de tokens consommés au total, la facture avait augmenté de 18 % et le temps de 9 %, alors que je m'attendais à l'inverse. Une seule catégorie de tokens avait augmenté : l'écriture dans le cache.

Ce résultat m'a amené à créer un "replay" représentant l'outil structurel déterministe parfait, sans aucune latence, et à réaliser un benchmark basé dessus. L'outil de replay contient la réponse "parfaite" typique sur un flow d'exécution, sans latence ni surcharge, et le bras correspondant l'obtient en cinq appels d'outil successifs. Au sixième appel, l'oracle affiche DONE : la réponse est complète.

Encore plus étonnant : avec ce scénario d'outil parfait, l'agent obtient la réponse en peu d'appels, mais une fois la réponse récupérée, il a tendance à la revérifier et à s'étendre, en continuant à consommer des tokens.

En chiffres, sur 5 rounds :


1. Motivation

Seam trace un flow de code à travers un dépôt : quels fichiers y participent, où il traverse plusieurs langages, couches et services puis où il se termine. L'hypothèse / motivation de départ était évidente : un outil qui répond en moins d'étapes qu'un agent qui avance à coups de grep devrait coûter moins cher que cet agent.

La première mesure, six rounds de grep contre Seam (bench/grep-vs-seam/results/kcC-*), a confirmé la première moitié et réfuté la seconde : 2,7x moins d'appels d'outils, et une facture 18 % plus élevée. Chaque catégorie de tokens que l'outil devait faire baisser a baissé - tokens de sortie -19 %, lectures du cache -19 %, temps d'API -19 % - et la facture a monté quand même, parce que la seule catégorie qui a augmenté est l'écriture dans le cache (x1,79). De plus, le temps total a augmenté de 9 %.

Le contexte / périmètre. Le dépôt utilisé comme étude est Keycloak, un monolithe contenant à la fois un client Typescript et un serveur Java, l'idéal donc dans le sens où on matérialise directement les plusieurs couches.

Les chiffres viennent de cinq séries de runs, toutes sur ce dépôt et cette tâche :

série rounds bras utilisée en dossier
première mesure 6 grep, Seam Introduction, §1, §4.2 bench/grep-vs-seam/results/ (kcC-*)
benchmark principal 5 grep, Seam, oracle partout ailleurs, dont le tableau ci-dessous bench/replay-ceiling/results/
oracle + recherche 5 grep, oracle, oracle + grep §5.2 bench/replay-ceiling/results-oracle-grep/
second modèle (Sonnet) 3 grep, oracle §6.2, §8.2 bench/replay-ceiling/results-sonnet-clean/
oracle réduit à la réponse 5 grep, oracle, oracle réduit §8.1 bench/replay-ceiling/results-min-payload/

Sauf mention contraire, un chiffre est une moyenne du benchmark principal.

par run, moyenne GREP SEAM REPLAY (idéal)
appels d'outils 22,4 14,4 20,8
tours du modèle 23,4 15,4 21,8
tokens de contexte / tour 41 882 83 955 57 152
tokens de thinking 1 108 2 177 (1,97x) 2 145 (1,94x)
écriture cache 36 779 62 923 49 991
lecture cache 943 264 1 229 982 1 195 918
temps total (mesuré par le shell) 85 s 119 s 89 s
appels refusés (dispositif) 0,0 1,6 4,6
coût facturé, brut 1,00 $ 1,42 $ (1,42x) 1,26 $ (1,26x)
coût facturé, ajusté 1,00 $ 1,36 $ (1,36x) 1,13 $ (1,13x)

Round par round (coût brut), pour montrer que ce n'est pas un effet de moyenne :

r1 r2 r3 r4 r5 plus cher
SEAM vs GREP 1,01x 1,37x 1,51x 1,68x 1,53x 4 sur 5, 1 à égalité
REPLAY vs GREP 1,26x 1,18x 1,00x 1,41x 1,48x 4 sur 5, 1 à égalité

"À égalité" signifie à moins de 1 % du contrôle. Aucun round n'est moins cher que grep.


2. Travaux associés

L'étude de la réduction des coûts par la réduction de tokens a déjà été menée. Token Reduction Is Not Cost Reduction (arXiv 2607.12161). Elle mesure 2 908 lancements de Claude Code, sur 103 tâches, 7 dépôts et 3 modèles. Elle traite un sujet corollaire, sans couvrir celui-ci. Elle montre en particulier :

Dans cette étude, je me concentre sur trois points qu'elle laisse ouverts :

  1. L'intervention opposée. Elle compresse : elle retire de la sortie d'outil pour économiser des tokens. Ici on injecte : un payload plus large en contrepartie de beaucoup moins d'appels. La direction est opposée et la conclusion reste la même : les coûts augmentent. C'est donc une étude complémentaire.
  2. L'isolation de la vérification. Avec une compression, l'agent peut légitimement relire ce qui a été coupé : relecture et manque d'information sont confondus. Ici rien n'est retiré et rien n'est faux : la réponse est complète. Toute vérification après DONE ne s'explique donc par aucun manque d'information.
  3. Le coût d'un outil parfait. Aucun travail de ce domaine ne mesure ce que coûterait un outil optimal, qui ne pourrait jamais exister en pratique, mais qui représente la meilleure version possible de tout outil de ce type : le replay.

Travaux voisins. Redundant or Necessary? (arXiv 2605.29893) construit un benchmark pour détecter les étapes redondantes d'un agent. Il les classe sans les chiffrer, et n'a pas de bras type oracle.

When the Tool Decides: LLM Agents Defer Blindly to Graph Neural Network Tools (arXiv 2606.14476) semble dire l'inverse de la section 5 : ses agents recopient la réponse de leur outil, un réseau de neurones sur graphe (un modèle qui prédit l'étiquette d'un nœud à partir de ses voisins). Mais il ne la contredit pas: son agent ne peut pas vérifier : l'outil lui donne directement l'étiquette qu'il doit rendre, et il n'a rien d'extérieur pour la contrôler. Seam et l'oracle nôtre ont le dépôt ouvert à côté et peuvent vérifier chaque affirmation. Cet article mesure aussi autre chose que nous (ce que l'agent fait de la réponse, pas combien d'appels il choisit de faire), et son effet extrême est en partie propre au modèle Qwen (selon ses propres auteurs)...


3. Méthode

3.1 Les bras et les contrôles

J'ai choisi une tâche précise, sur un commit fixe du dépôt Keycloak, sur laquelle trois bras ont été exécutés à la suite, puis les résultats compilés et comparés.

Le modèle est fixé: (claude-opus-5[1m]). Le CLI facture aussi un petit modèle dans chaque run, environ 0,5 % du coût, inclus dans tous les totaux.

L'ordre des bras est tiré au hasard à chaque round. La contamination entre bras est vérifiée dans les transcripts, pas supposée à partir des options : les cinq rounds sont propres.

La seule capacité qui diffère est la recherche de contenu : tous les bras ont les mêmes commandes de lecture et de listing, et l'outil Read. Seul le bras A a rg, grep, Grep et Glob.

Avant de publier l'ensemble de ces rounds, deux series de runs ont ete ecartees car le dispositif de test etait defaillant, pour les causes suivantes:

  1. Le premier round (pilote), l'oracle a pu lancer des commandes qui lui etaient interdites
  2. Durant la seconde serie (de trois rounds), grep pouvait lire des fichiers morceaux par morceaux alors que les deux autres bras n'avaient pas le "droit", gonflant leur cout.

Ces runs n'ont donc pas ete utilises ici, mais sont conserves dans le repository (bench/replay-ceiling/results/discarded-*/WHY.md).

3.2 L'instrument : l'oracle de replay est une borne supérieure

call-flow --step N constitue l'oracle en retournant successivement cinq fichiers enregistrés, dans un ordre particulier imposé, puis affiche DONE. Chaque étape est la sortie exacte qu'un vrai run de Seam a produite sur cette question et ce commit, que j'ai "sauvegardée" à un instant T (stockée ici : bench/replay-ceiling/steps/), et aucune information n'a été ajoutée. Une seule retouche : le nom de l'outil a été effacé de l'étape 2 (quelques mots comme seam ou SEAM_ remplacés par des termes neutres, et une ligne retirée, qui suggérait une commande seam que le bras C n'a pas), pour que l'agent ne sache pas quel outil il remplace. L'original est conservé à côté (steps/step2.txt.orig).

Cette mise en place d'oracle supprime toutes les façons dont un outil de récupération pourrait perdre :

supprimé bras C (REPLAY) bras B (SEAM)
latence du moteur ~1 ms (un cat) - indiscernable du contrôle +20,6 s hors API par run
mauvais chemins, mauvais point de départ aucun : ordre fixé à l'avance l'agent choisit
coût de la documentation ~300 octets 42 Ko, présents à chaque tour
rappel 100 % de la vérité terrain par construction mesuré

Qu'est ce que contient notre payload ?

Le payload est le texte que l'outil injecte dans le contexte de l'agent. Ici, les cinq étapes livrent 43 Ko de texte, environ 13k tokens :

  1. la table des routes : 147 routes trouvées, dont une seule résolue des deux côtés, celle que la tâche demande
  2. la carte pour l'agent (27 Ko, l'essentiel du payload) : la région du code à lire au lieu d'enchaîner des grep, avec les lignes de code source
  3. le couplage entre les deux langages de la ressource Java, indexé par route plutôt que par symbole
  4. et 5. huit symboles nommés, chacun résolu en un fichier et une ligne

(Un détail explique la taille du payload : getRealm a 207 définitions dans le dépôt, et l'outil en renvoie 25 en laissant l'agent choisir)

Un outil structurel est gros en partie car il ne porte pas de décision / jugement sémantique et ne peut donc trancher : il explique honnêtement qu'il ne peut pas réduire, et cette honnêteté coûte des tokens.

Coût pour le reproduire sur n'importe quel outil : figer les sorties de l'outil sur une tâche, les servir avec cat, écrire un manuel de 300 octets.

Le temps hors API (temps total moins temps d'API) n'est qu'une approximation grossière du temps du moteur : il est même légèrement négatif pour le contrôle. Avec Seam, le temps du "moteur" ajoutait +20,6s, ce qui n'est pas ignorable. Celui de l'oracle est donné comme indiscernable du contrôle plutôt que comme un chiffre.

3.3 Modèle de coût (rappel sur le fonctionnement existant de la facturation actuelle des LLMs)

Quatre catégories de tokens facturés dans chaque run enregistré :

entrée          5,00 $ /Mtok
lecture cache   0,50 $ /Mtok    payée À CHAQUE tour, sur tout le prompt
écriture cache 10,00 $ /Mtok    payée UNE FOIS par octet, au tour où il entre dans le contexte
                                (TTL 1 h. TTL 5 min = 6,25 $)
sortie         25,00 $ /Mtok

4. Le mécanisme de coût

Cette section reprend un mécanisme déjà établi par l'étude 2607.12161, ce n'est pas un résultat de cette étude.

=> L'idée : le surcoût d'un outil de récupération de code vient de la façon dont le cache est écrit et lu. À chaque tour, toute la conversation est renvoyée au modèle : le prompt initial, les payloads des outils et toutes les réponses précédentes. Elle grossit donc à chaque tour. Un payload agit alors de deux façons :

  1. il alourdit chaque tour suivant, puisqu'il est relu à chaque tour (§4.1)
  2. il est écrit une fois dans le cache, à 20x le prix d'une lecture, et moins il reste de tours après lui, moins cette écriture s'amortit (§4.2).

Un même payload joue sur les deux à la fois, en sens opposé : s'il est gros, il permet de s'arrêter plus tôt, mais il pèse sur chaque tour restant, et plus on s'arrête tôt, moins son écriture est amortie. S'il est petit, il ne permet pas de gagner vraiment sur grep.

Un payload, deux factures

Figure 1. Les deux termes et leurs prix : 0,50 $/Mtok payés à chaque tour restant, contre 10,00 $/Mtok payés une fois.

4.1 Le contexte total

Le contexte total utilisé est défini par :

    context_per_turn     =  (cache_read + cache_write) / turns
    total input context  =  turns  ×  context_per_turn

Ce qui signifie que les coûts sont liés à la somme des contextes sur tous les tours, pas à la taille finale du contexte. Effectuer deux fois moins de tours avec un contexte deux fois plus gros n'apporte donc rien. Un payload ne fait baisser la lecture que s'il supprime plus de tours qu'il n'alourdit chacun d'eux, donc si le contexte total du bras finit sous celui du contrôle :

par run, moyenne tours dont refusés contexte / tour contexte total vs GREP
GREP 23,4 0,0 41,9k 980k 1,00
SEAM 15,4 1,6 84,0k 1 293k brut · 1 159k ajusté 1,32 brut · 1,18 ajusté
REPLAY (idéal) 21,8 4,6 57,2k 1 246k brut · 983k ajusté 1,27 brut · 1,003 ajusté

La ligne ajustée compte tous les appels sauf les refusés. Elle compare un outil utilisé à côté de grep. La ligne brute sert à une comparaison directe avec grep lorsque l'outil le remplace.

La ligne ajustée de REPLAY n'est pas l'idéal : elle contient deux limites. La première est DONE, qui matérialise la dernière réponse utile de l'outil et marque la fin des données. La seconde est atteinte lorsque l'agent juge qu'il possède suffisamment d'informations et s'arrête. L'idéal s'arrêterait à DONE. L'écart entre les deux est lourd de conséquences, et aboutit à la conclusion finale de ce papier.

Concrètement, le bras idéal avait la réponse complète à 346k, environ un tiers de ce que lit grep. Côté lecture, il gagne donc largement. Ce qui le ramène sur la ligne de grep, ce sont les 637k que l'agent passe ensuite à vérifier une réponse déjà complète. Seam, lui, perd l'échange dans les deux cas (1,18).

Contexte total par run, appels refusés séparés

Figure 2. Chaque barre est le contexte total d'un bras (tours × contexte par tour), sur une même échelle. L'extrémité hachurée correspond aux appels refusés, seule partie que l'ajustement retire. La ligne verticale marque le contrôle. La barre du bras idéal est coupée là où sa réponse est devenue complète (DONE, au 6e appel dans chaque round) : 346k pour y arriver, puis 637k de vérification. Seul ce bras peut être coupé ainsi, parce que lui seul a un marqueur de fin. Sans les refus, il s'arrête sur la ligne, et près des deux tiers de ce qui l'y amène est de la vérification.

4.2 L'inversion de l'amortissement

Le surcoût vient de l'écriture. Une écriture coûte 2,0x le prix d'une entrée, une lecture 0,1x : la lecture coûte donc 20x moins. Un payload n'est rentable que si chaque token qu'il ajoute au contexte économise au moins vingt tokens de relecture (un rapport inférieur à 0,050). Avec un cache de 5 minutes, l'écriture coûte 1,25x et le seuil est de 0,080.

Avec la ligne ajustée de §4.1, la lecture est neutre. Tout ce que l'outil idéal coûte de plus que le contrôle vient donc de l'écriture :

écart de coût ajusté du bras C par rapport à GREP :
    écriture cache   +0,1321 $      <- la totalité
    lecture cache    -0,0051 $      <- indiscernable de zéro
    sortie           +0,0047 $
    TOTAL            +0,1317 $      = +13 %
Où va l'argent de l'outil idéal

Figure 5. L'outil idéal lit autant que grep: tout son surcoût vient de l'écriture dans le cache

L'essentiel du surcoût de l'oracle et d'un outil idéal est dans la mise en place de ce dernier. Par mise en place, on entend l'écriture dans le cache elle-même, qui est payée une fois par octet lors du tour où l'octet entre dans le contexte de l'agent. Ceci implique une notion d'amortissement au fil des appels: plus il reste d'appels après la mise en place, plus le coût de cette dernière peut "s'étaler" dans les tours.

En tant qu'exemple, un octet écrit une fois puis lu T fois coûte (10 + 0,5T)/T dollars par million de tokens et par tour d'utilisation :

tours après le payload 20 10 4 2 1
prix effectif ($/Mtok-tour) 1,00 $ 1,50 $ 3,00 $ 5,50 $ 10,50 $

Chaque tour possède une partie d'écriture, et ce qui est nouveau depuis le tour précédent passe par le même calcul de coûts. Le prompt coûte au tour 1 (14,1k, à peu près identique dans tous les bras), puis chaque résultat d'outil au tour qui suit son retour.

Les cinq étapes de l'oracle arrivent aux tours 2 à 6, et l'une domine : dans l'étape 2, la carte qui pèse en tout 11,7k, écrite au tour 3.

Les résultats de grep sont écrits de la même façon, par morceaux d'environ 1k à 3k répartis sur tout le run.

Le problème : un outil de récupération suffisamment optimisé a justement pour objectif de diminuer les tours, ce qui raccourcit la période sur laquelle sa propre écriture s'amortit.

=> En admettant qu'on atteigne un seul appel, chaque octet du payload coûtera environ 20x le prix d'une lecture, là où grep a le profil inverse : ses octets arrivent tard, sont relus peu de fois, mais au prix normal.

L'inversion de l'amortissement

Figure 3. Un octet écrit une fois et lu T fois coûte (10 + 0,5T)/T par Mtok-tour. Réduire les tours fait glisser l'outil vers la gauche de la courbe, vers la prime complète de 20x sur ses propres octets.

Ce qui s'est passé quand les tours ont vraiment baissé. Dans la première mesure (§1, 6 rounds), Seam a divisé les tours par 2,6 (de 24,7 à 9,7). Pour cela, il a ajouté 24,1k tokens d'écriture et économisé 136,8k tokens de lecture : un rapport de 0,176, soit 3,5x au-dessus du seuil.

=> Pour être rentable, son payload aurait dû tenir en 6 838 tokens (la carte seule en fait environ 7k), ou il aurait fallu répondre en 3,9 tours, moins que ses 8,7 appels d'outils.

Attention Ce calcul ne rend pas impossible un vrai outil à un seul appel. Avec un payload hypothétique de 36k tokens et un seul tour, l'écriture coûte 0,36 $, contre environ 0,49 $ de lecture accumulée pour grep : il gagnerait. La section 8 le mesure : réduit à la réponse seule, l'oracle gagne, dans la limite du plancher de la section 5.

4.3 Le "thinking" double, et ne pèse presque pas sur la facture

Mesuré directement depuis les outils d'Anthropic, le contrôle "pense" 1 108 tokens par run, Seam 2 177 (1,97x) et le bras idéal 2 145 (1,94x).

La partie thinking double en comparaison avec grep:

Où ce thinking a lieu est un résultat de la section 5 : 99 % se trouve après DONE.


5. Résultat : le plancher de vérification

En résumé : le plancher de vérification, ce sont des tours entièrement consacrés à vérifier la réponse alors qu'elle est déjà construite et connue. Je parle de "plancher", car améliorer la réponse de l'outil ne parvient pas à le faire baisser : même avec une réponse parfaite et complète, l'agent continue de vérifier.

Le plancher de vérification

Figure 4. Le bras idéal, seul : les autres bras n'ont pas de marqueur DONE, donc la quantité n'est pas mesurable pour eux. 6 appels mènent à la réponse prouvée complète, 14,8 suivent, et les 23 refus des cinq rounds tombent tous dans cette seconde partie.

REPLAY (idéal), par run appels d'outils dont exécutés dont refusés part du coût du run
avant DONE : obtenir la réponse 6,0 6,0 0,0 48 %
après DONE : la vérifier 14,8 10,2 4,6 52 %

Sur le bras idéal, DONE est atteint au bout de 6 appels. Les 20,8 appels du run (en moyenne sur 5 rounds) se répartissent donc en 6 appels pour obtenir la réponse et 14,8 appels de vérification, dont 4,6 sont des appels refusés. L'agent termine en 21,8 tours contre 23,4 pour grep : 7 % de moins, avec un outil qui lui avait déjà donné toute la réponse.

Si on reprend la figure 2, on note que 346k de contexte sont nécessaires pour atteindre la réponse, et 637k sont consacrés à la vérification (plus 263k d'appels refusés). => La vérification seule lit 65 % de ce que grep lit pour toute la tâche. 99 % du thinking du bras idéal se trouve dans cette phase : 19 tokens par run pendant les six appels qui apportent la réponse, 2 126 pendant la vérification. Le modèle ne réfléchit presque pas pendant que la réponse arrive : il réfléchit pendant qu'il vérifie une réponse déjà complète.

Les 14,8 appels représentent 71 % des appels du bras, mais seulement 52 % de son coût. C'est le mécanisme d'amortissement (section §4.2) à l'intérieur d'un seul run : les sept premiers appels portent 67 % de l'écriture dans le cache, parce que le payload y arrive, et la longue suite après DONE relit à un vingtième de ce prix.

Il faut quand même noter que le plancher a une limite et un agent qui reçoit une réponse d'outil qu'il ne peut pas vérifier la recopie au lieu de la vérifier (§2). Dans notre cas, le dépôt est ouvert à côté de l'agent, donc chaque affirmation de l'oracle peut être vérifiée.

5.1 La vérification survit à un outil "parfait"

Dans le bras idéal, tout ce qui sert à obtenir la réponse est au mieux (voir section §3.2) : aucune latence, une réponse complète, un manuel de 300 octets.

L'agent vérifie quand même : 10,2 appels exécutés après DONE. Une seule chose lui manque : un moyen simple de vérifier. Après DONE, l'oracle n'a plus rien à donner et la recherche est refusée, donc chaque vérification passe par la lecture de fichiers entiers. La section 5.2 lui donne la recherche et mesure la différence.

5.2 L'agent vérifie-t-il autant parce qu'il n'a pas de bon moyen de vérifier ? Une piste à vérifier : le bras D

Le bras D est le bras idéal munit de la recherche ordinaire. Si la vérification après DONE n'était que le prix de l'absence de recherche, le bras D vérifierait beaucoup moins. Les bras A, C et D ont tourné ensemble, cinq rounds appariés dans un ordre tiré au hasard, sur une même machine (bench/replay-ceiling/results-oracle-grep/).

par run, après DONE REPLAY (sans recherche) REPLAY + grep (bras D)
tentatives de recherche refusées 7,8 0
recherches exécutées 0 6,2
lectures de fichiers exécutées 17,0 9,6
autres (ls, find) 1,4 0
vérifications réellement exécutées 18,4 15,8

Une commande qui lit et cherche à la fois (sed ... && grep ...) compte comme une recherche, puisqu'elle en exécute une.

par run, sur tout le run - cette machine GREP REPLAY REPLAY + grep
appels d'outils 35,2 32,2 21,8
coût facturé vs GREP 1,00 1,23 brut · 1,06 ajusté 0,91

Trois résultats :

  1. La quantité de vérifications ne baisse presque pas Le nombre d'appels du bras D après DONE baisse de 10,4, mais 7,8 d'entre eux sont les tentatives refusées, qui cessent simplement dès que la recherche est permise. Ce qui change, c'est la nature de ces appels : environ la moitié des lectures de fichiers entiers deviennent des recherches ciblées.
  2. Le plancher résiste au moyen de vérifier. Il a suivi l'oracle jusqu'à DONE dans chaque round, sans rien chercher avant.
  3. En coût, l'outil idéal utilisé à côté de grep est au niveau de grep seul. Ses vérifications coûtent moins cher, très probablement parce qu'une recherche renvoie moins de texte qu'un fichier entier : le bras D est moins cher que le bras idéal sans recherche dans les 5 rounds en brut, et dans 4 sur 5 en ajusté. Le bras idéal sans recherche perd toujours, dans le même sens que les rounds publiés. => La conclusion dépend donc de l'usage que distingue §6.1 (point 4) : utilisé à la place de grep, l'outil idéal perd. Utilisé à côté de grep, il arrive à l'égalité, sans jamais réussir à gagner.

6. Menaces à la validité

6.1 Les asymétries entre les bras

  1. Seam "paie" sa propre documentation. Son SKILL.md est inclus dans le prompt : au premier tour, Seam écrit 30,9k tokens dans le cache contre 14,0k pour grep (+16,8k, identique dans les 5 rounds), et ce texte reste présent pendant tout le run. C'est le produit tel qu'il est livré, donc l'enlever serait injuste dans l'autre sens.
  2. Seam a un cache à mettre en place. grep et l'oracle n'en ont pas. Cela favorise Seam.
  3. L'oracle est construit à partir des sorties de Seam, en choisissant les cinq résultats qui couvrent ensemble toute la vérité terrain.
  4. Seam et l'oracle n'ont pas accès à la recherche : il faut dire sur quel coût repose chaque affirmation.
    • Si l'outil est présenté comme un remplaçant de grep, les refus sont une vraie gêne qu'un utilisateur rencontrerait, et c'est la ligne brute qui compte.
    • S'il est présenté comme un complément de grep, ce qui est le cas de Seam, les refus viennent du dispositif, et c'est la ligne ajustée qui compte. Le bras D mesure directement ce cas au lieu de l'ajuster : l'outil idéal avec grep coûte 0,91x grep seul, ce qui n'est pas distinguable de l'égalité (§5.2).
    • Le plancher de vérification (§5) tient dans les deux cas. La parité de §4.1 repose sur la lecture ajustée. Il faut annoncer l'usage avant de citer un chiffre.

6.2 Généralité


7. Ce que cette étude ne dit pas


8. Ouverture

8.1 Un outil réduit à la réponse : le bras E

L'oracle de cette étude est optimal en latence, en ordre et en rappel, mais pas en taille : il sert les ~13k tokens réels de Seam. Le bras E est le même oracle réduit à la réponse seule : un seul appel, qui renvoie les 12 emplacements de la vérité terrain (fichier:ligne#symbole) et le passage REST, soit 1,7 Ko (environ 500 tokens), puis DONE. Même prompt, mêmes commandes autorisées, pas de recherche. Les bras A, C et E ont tourné ensemble, cinq rounds appariés dans un ordre tiré au hasard, sur Opus et sur une même machine (bench/replay-ceiling/results-min-payload/).

par run GREP REPLAY (C) REPLAY réduit (E)
coût vs GREP 1,00 1,25 0,45
rounds moins chers que grep - 1 sur 5 5 sur 5
écriture dans le cache 45k 48k 22k
vérifications exécutées après DONE - 20,4 10,2

La question reste entière : un tel outil est-il constructible ? Pour réduire le payload à la réponse, il faut trier les données utiles des superflues. Or ce tri dépend de la question de l'utilisateur, en langage naturel : c'est un jugement sémantique, pas un fait structurel. Construire exactement E revient à résoudre la tâche. Au sens strict, il n'est donc pas constructible. Mais on peut s'en approcher :

Et même un tri parfait reste plafonné par le plancher de vérification.

8.2 La taille du plancher dépend-elle du modèle ?

Sur Sonnet 5, l'oracle a fait moins de vérifications après DONE (7,0 en moyenne contre 10,2, sur 3 rounds) et a coûté à peu près autant que son contrôle, au lieu de 1,26x (§6.2). Si cela se confirme à 5 rounds, une partie de la valeur mesurée d'un outil de récupération dépend de la quantité de vérification du modèle, pas de l'outil. Il faudrait les bras A et C sur 5 rounds ou plus, sur les deux modèles, sur une même machine.


Section générée par IA

Annexe A - Reproduction

bench/replay-ceiling/run-arms.sh <round-id>          # un round = trois bras, dans un ordre tiré au hasard
python3 bench/replay-ceiling/measure.py              # décomposition du coût, seuil de rentabilité, plancher de vérification
python3 bench/replay-ceiling/verify_independent.py   # une seconde implémentation, sans aucun code en commun

verify_independent.py recalcule chaque chiffre de cette étude à partir des transcripts bruts, sans importer measure.py. Deux implémentations qui n'ont jamais partagé de code doivent tomber d'accord, sinon l'une des deux est fausse. Elles sont d'accord sur chaque chiffre ; là où elles ne l'étaient pas au départ, et ce qui a changé, est décrit dans STUDY_AUDIT.md. Les tableaux round par round sont affichés par les deux scripts.

Annexe B - Relecture externe

L'ajustement des refus (§1, §4.1) vient d'une relecture externe, qui a repéré que des tours refusés étaient comptés comme du comportement de l'agent. La leçon dépasse ce cas : un audit de contamination vérifie que le contrôle a tenu ; il ne vérifie pas si les coûts propres au dispositif sont mis sur le compte du bras testé.


Déclaration d'usage de l'IA

Cette étude a été menée avec l'aide de Claude Code (Anthropic), sous ma direction. L'outil Seam, le dispositif de benchmark, l'oracle de replay, les scripts d'analyse et le vérificateur indépendant ont été écrits par l'agent à partir de mes instructions ; l'agent a aussi aidé à relire, corriger et traduire le texte.

Ecrit en francais par l'auteur. La traduction anglaise, les Annexes ainsi que cette declaration ont ete produites par Claude et revues par l'auteur.


Références