Aller au contenu
English

Contenir un agent emballé

  • Étude de cas 2
  • 150 min
  • Facultative · 1 étude de cas requise pour le certificat

Où nous en sommes

Dans ce cours, une limite d'étapes et un quota ont arrêté l'agent emballé de Larkfield à un coût connu. Mais nous avions construit cette boucle exprès et choisi ses limites. Dans cette étude de cas, nous rejouons 456 exécutions réelles enregistrées de l'agent d'une autre équipe dans nos passerelles. Nous mesurons ce que chaque contrôle aurait arrêté et quelles bonnes exécutions il aurait arrêtées par erreur.

Ce que vous saurez faire

Choisissez les limites qui contiennent un agent emballé, à partir de ses propres exécutions enregistrées. Vous rejouez 456 exécutions réelles d’un agent de soutien ouvert dans les passerelles de modèles et d’outils du cours. Vous mesurez les économies de chaque contrôle et les bonnes exécutions qu’il arrête par erreur. Vous testez ensuite votre choix sur deux autres modèles et rédigez une recommandation.

Étude de casPièce de portfolio

Licence
MIT
Durée
Environ 2,5 heures
S’exécute dans
VS Code, Python 3.12+
Compétences utilisées
  • Rejeu d'exécutions d'agent enregistrées
  • Limites d'étapes
  • Quotas quotidiens
  • Une limite de répétition à la passerelle d'outils
  • Arguments d'outils stricts
  • Blocages à tort
  • Une mesure pour une comparaison équitable
  • Une marge pour les nouvelles entrées
  • Recommandation de limites

Décompressez le projet de départ, ouvrez le dossier dans VS Code et suivez les étapes ci-dessous. Elles commencent par un nouvel environnement virtuel.

Cette étude de cas est un dossier de projet, pas un carnet (notebook) Jupyter. Le travail utilise les passerelles du cours. Le rejeu envoie chaque appel enregistré dans gateway/app.py et toolgate/app.py de votre projet de cours. Un carnet dans Colab ne les aurait pas. Le dossier est petit (environ 0,5 Mo) et n’ajoute aucun paquet.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 150 minutes

Ce que vous devez savoir

Cette étude de cas utilise tout le cours. Ces leçons comptent le plus :

Cette page enseigne un contrôle absent du cours : une limite de répétition à la passerelle d’outils.

Ce qu’il vous faut sur votre ordinateur

  • Le projet de cours dans son état final, dans ~/projects/ai-estate, avec son environnement virtuel. Si le vôtre ne fonctionne plus, téléchargez l’instantané end-of-m07 du cours et suivez son README.
  • Les services du parc n’ont pas besoin de fonctionner. Le rejeu démarre tout le nécessaire dans un seul processus, dans un nouveau dossier temporaire, puis le supprime à la fin. Votre dossier state/ ne change pas.

Testé sur macOS (Apple silicon) avec Python 3.12.13 et les paquets du projet de cours. Les commandes Windows (PowerShell) et Linux sont rédigées, mais n’ont pas été exécutées.

Ingrid (elle) dirige la plateforme d’une compagnie de téléphonie régionale (inventée pour cette étude de cas). Son équipe a mis en place la conception du cours : une passerelle de modèles, une passerelle d’outils et un enregistrement par agent. Maintenant, Tariq (il), ingénieur en IA, veut enregistrer le premier agent de la compagnie qui interagit avec les clients. Il répond aux clients dans le clavardage de soutien. Il consulte leur ligne et leur facture, règle les problèmes de données et d’itinérance et envoie des demandes de paiement. Lorsqu’il ne peut pas aider, il transfère le client à une personne.

Ingrid pose une question avant la révision : « Quelles limites inscrivons-nous dans son enregistrement? » Chaque mauvaise réponse a un coût :

  • Une limite trop permissive laisse tourner une boucle. La boucle dépense de l’argent et le client attend dans un clavardage qui n’avance pas.
  • Une limite trop stricte arrête une conversation qui se déroulait bien. Un client satisfait est transféré à une personne pour rien.

Tariq n’a pas encore ses propres exécutions. Ingrid propose donc une méthode pour tout agent : prendre les exécutions enregistrées d’un agent semblable. Puis les rejouer dans les passerelles avec chaque limite envisagée et compter les deux types d’erreurs. L’agent de la compagnie sera différent. Ses propres exécutions devront donc servir à revérifier les limites après le lancement.

Vous allez construire une recommandation de limites à partir d’exécutions d’agent enregistrées. Vous vérifiez les données, examinez la longueur des exécutions et établissez une référence de base. Ensuite, vous terminez deux contrôles et comparez quatre contrôles selon une même mesure. Vous choisissez un réglage avec une marge et le confirmez dans les vraies passerelles. Enfin, vous testez ce choix sur les exécutions de deux autres modèles, comme si l’équipe changeait de modèle.

  1. Téléchargez le projet de départ dans l’encadré en haut de cette page. Décompressez-le dans ~/projects, pour placer le dossier runaway-replay à côté de ai-estate.

  2. Dans VS Code, choisissez File > Open Folder (fichier, ouvrir un dossier), puis ouvrez runaway-replay. Ouvrez ensuite un terminal : Terminal > New Terminal (terminal, nouveau terminal).

  3. Activez l’environnement virtuel du projet de cours :

    Fenêtre de terminal
    source ../ai-estate/.venv/bin/activate

    Si votre projet de cours est dans un autre dossier, définissez ESTATE_PROJECT avec ce dossier (PowerShell : $env:ESTATE_PROJECT = "C:\path\to\ai-estate").

  4. Exécutez les tests : python -m pytest -q. Le projet de départ comporte deux parties à terminer. Cinq tests échouent donc :

    FAILED tests/test_controls.py::test_a_step_limit_of_4_stops_only_the_loop - a...
    FAILED tests/test_controls.py::test_a_step_limit_of_2_also_stops_the_success
    FAILED tests/test_controls.py::test_a_repeat_limit_of_2_refuses_the_third_identical_call
    FAILED tests/test_gateway.py::test_a_step_limit_through_the_gateway_matches_the_arithmetic
    FAILED tests/test_gateway.py::test_a_repeat_limit_through_the_tool_gateway_matches_the_arithmetic
    5 failed, 9 passed in 6.56s

    Si les tests des passerelles sont plutôt ignorés, le projet n’a pas trouvé votre projet de cours : vérifiez ESTATE_PROJECT.

Le projet terminé se trouve dans le même encadré, pour comparer avec votre travail. Tous les résultats de cette page en proviennent.

Les données sont les résultats publiés de τ²-bench, un banc d’essai ouvert d’agents d’IA qui parlent aux clients et utilisent des outils. Son domaine télécom est le service de soutien d’une compagnie de téléphonie. Un client a un problème de téléphone, et l’agent dispose de 13 outils et d’une politique à suivre. Un deuxième modèle joue le client.

Ingrid avait besoin de quatre choses : les jetons de chaque appel de modèle, les appels d’outils avec leurs arguments, la fin de chaque exécution et quelques vraies boucles. Les exécutions ouvertes d’agents de programmation (SWE-agent, SWE-smith, OpenHands) n’ont pas de comptes de jetons. Chaque ensemble occupe de 1 à 3 Go. Les fichiers d’expériences de SWE-bench ont des comptes de jetons, mais aucune licence. Les exécutions de τ²-bench pour le commerce de détail ne bouclaient pas. Ses exécutions télécom de gpt-4.1-mini contiennent 32 vraies boucles.

La journée de conception comprend 456 exécutions de gpt-4.1-mini : nous choisissons les limites à partir de celles-ci. Les exécutions de gpt-4.1 et d’o4-mini sont les nouvelles entrées pour la fin. Une exécution possède ces champs :

Champ Ce qu’il contient
id, task_id, trial l’exécution; l’une des 114 tâches; chaque tâche a été exécutée 4 fois
termination_reason, reward sa fin : l’arrêt du banc d’essai à 200 messages (une exécution emballée), ou une fin normale avec une récompense de 1 (réussite) ou de 0 (échec)
steps[].prompt_tokens, completion_tokens un appel de modèle de l’agent, avec ses comptes de jetons enregistrés
steps[].tools[] les appels d’outils demandés par le modèle : name (nom), arguments (arguments) et error (erreur : l’outil a répondu par une erreur)

replay/data.py vérifie le SHA-256 de chaque fichier avant de le lire. Exécutez la première partie de la comparaison :

Fenêtre de terminal
python -m replay.compare

Les premières lignes :

Design day: 456 runs of gpt-4.1-mini-2025-04-14 (114 tasks x 4 trials), 13,269 model calls, 8,322 tool calls, 134,545,262 tokens, US$13.73 at chat-small's price
success 200 runs | calls per run: median 19.0, max 44 | US$3.24 (24% of the day), US$0.0162 a run
failure 224 runs | calls per run: median 27.0, max 87 | US$5.97 (43% of the day), US$0.0267 a run
runaway 32 runs | calls per run: median 97.0, max 100 | US$4.52 (33% of the day), US$0.1412 a run

Ce que cela nous apprend. Les exécutions emballées représentent 7 % des exécutions, mais un tiers des dépenses de la journée. Une exécution emballée coûte environ neuf fois plus qu’une exécution réussie. Aucune exécution réussie n’a fait plus de 44 appels de modèle, tandis que les exécutions emballées en ont fait près de 100. Le banc d’essai a arrêté chaque exécution emballée à 200 messages, soit environ 100 appels de l’agent. Ces coûts sont donc un plancher : sans cet arrêt, une boucle continue.

L’unité est une exécution, et son identifiant va dans X-Run-Id, comme dans Quotas, budgets et limites de débit. La journée comprend les 456 exécutions, l’une après l’autre, dans un ordre mélangé fixe. C’est une journée construite : le banc d’essai a exécuté ses tâches par lots.

Le prix est le même pour chaque jeton enregistré : celui de chat-small du cours. Il est de 0,10 $ US en entrée et de 0,50 $ US en sortie par million de jetons. Les coûts enregistrés dans les fichiers comprennent des rabais que les comptes de jetons ne montrent pas. Un prix unique compare les contrôles selon le comportement de l’agent, pas selon les listes de prix.

La mesure. Ingrid refuse un contrôle d’emballement qui arrête une exécution qui aurait réussi. Nous appelons cela un blocage à tort. La mesure est donc : les dollars US qu’un contrôle économise sur la journée, sans aucun blocage à tort. Chaque contrôle reçoit son réglage le plus strict sans blocage à tort sur la journée de conception. Nous comparons les économies de ce réglage. Les exécutions échouées qu’un contrôle arrête sont neutres : elles se terminaient mal de toute façon, et une personne devait aider.

La règle du rejeu. Un enregistrement montre ce qui s’est passé après chaque réponse reçue par l’agent. Après une réponse différente, l’enregistrement ne peut pas indiquer ce que l’agent ferait ensuite :

Un flux. Une exécution enregistrée : l'appel de modèle i, ses jetons, les appels d'outils qu'il a demandés. Il passe dans la passerelle de modèles avec X-Run-Id : la limite d'étapes compte les appels de cette exécution, le quota quotidien compte les jetons de l'agent aujourd'hui. Refus avec 429 : l'enregistrement se termine ici, l'exécution est arrêtée, sa tâche est transférée à une personne. Réponse : le fournisseur de remplacement répond avec les comptes de jetons enregistrés, facturés au prix de chat-small, et la passerelle écrit une ligne d'utilisation. Chaque appel d'outil passe ensuite à la limite de répétition : même outil et mêmes arguments, combien de fois dans cette exécution? Refus avec 429 : l'exécution est arrêtée. Sinon, la passerelle d'outils vérifie l'outil enregistré, les arguments stricts et la politique, puis écrit une ligne d'utilisation. Refus, alors que l'enregistrement avait une réponse : l'exécution est arrêtée. Refus, alors que l'enregistrement avait aussi une erreur : l'exécution continue comme dans l'enregistrement. Réponse : l'exécution continue avec l'appel de modèle suivant.
La règle du rejeu. Une exécution est suivie seulement tant que la plateforme donne à l'agent la même réponse que l'enregistrement. Une réponse différente termine l'enregistrement, et l'exécution compte comme arrêtée.
Description textuelle du diagramme

Une exécution enregistrée passe dans la passerelle de modèles, appel par appel, avec son identifiant d’exécution. Un refus de la limite d’étapes ou du quota arrête l’exécution, et sa tâche est transférée à une personne. Un fournisseur de remplacement répond à chaque autre appel avec les comptes de jetons enregistrés. Chaque appel d’outil rencontre ensuite la limite de répétition et les vérifications de la passerelle d’outils. Un refus là où l’enregistrement avait une réponse arrête l’exécution. Un refus là où l’enregistrement avait aussi une erreur laisse l’exécution continuer.

Le simulateur de fournisseur du cours répond seulement aux requêtes enregistrées par le cours. Un petit fournisseur de remplacement répond donc à chaque appel rejoué avec ses comptes de jetons enregistrés. La passerelle le tarifie, le compte et l’enregistre comme tout autre appel.

  • Exécutions réussies
  • Exécutions échouées
  • Exécutions emballées
La journée de conception : 456 exécutions de gpt-4.1-mini dans le domaine télécom de τ²-bench, comptées par classes de 5 appels.
Description textuelle du graphique

Trois courbes selon le nombre d’appels de modèle dans une exécution, par classes de 5. Exécutions réussies, au nombre de 200 : 167 ont de 6 à 25 appels, et aucune n’en a plus de 44. Exécutions échouées, 224 : un peu plus longues, 152 ont de 21 à 40 appels, et quelques-unes vont jusqu’à 87. Exécutions emballées, 32 : aucune sous 77 appels, et 24 entre 96 et 100, là où le banc d’essai les a arrêtées.

Ce que cela nous apprend. Il y a un écart : la plus longue exécution réussie a fait 44 appels, et la plus courte exécution emballée, 77. Toute limite d’étapes dans cet écart arrête toutes les exécutions emballées et aucune réussite. Mais cet écart est propre à cet agent sur ces tâches. Un autre agent, ou le même agent sur des tâches plus difficiles, peut avoir besoin de plus d’appels.

La première exécution emballée arrêtée par le rejeu concerne un client ayant un problème de données mobiles à l’étranger. L’agent a demandé le même client par numéro de téléphone 32 fois, la même ligne 31 fois et le même appareil 28 fois. Il a écrit au client seulement 6 fois en 99 appels. Les appels 61 à 72 ont demandé ces outils, dans cet ordre :

get_details_by_id, get_customer_by_phone, get_details_by_id, get_details_by_id, get_customer_by_phone,
get_details_by_id, get_details_by_id, get_customer_by_phone, get_details_by_id, get_details_by_id,
get_customer_by_phone, get_details_by_id
  • A runaway (99 calls)
  • A successful run of the same task (20 calls)
Comptes de jetons enregistrés (τ²-bench, gpt-4.1-mini). Chaque appel envoie toute la conversation jusque-là, donc les appels d'une longue exécution grossissent.
Description textuelle du graphique

Deux courbes de jetons de requête par appel. L’exécution emballée commence à 6,303 jetons et monte à 23,113 lors de son dernier appel, 99. L’exécution réussie de la même tâche se termine après 20 appels, à 9,554 jetons.

Ce que cela nous apprend. Une boucle coûte plus cher à chaque appel, car chaque appel renvoie toute la conversation. Cette exécution emballée a coûté 0.148 $ US. Ses 50 premiers appels ont coûté seulement 0.054 $ US, soit environ un tiers. Une limite qui arrête une boucle à mi-chemin économise donc plus de la moitié de son coût.

Une référence de base : aucune limite, puis les limites d’un autre agent

Section intitulée « Une référence de base : aucune limite, puis les limites d’un autre agent »

La référence de base est la journée de conception dans les vraies passerelles, sans limite. L’exécution prend environ 20 secondes :

Fenêtre de terminal
python -m replay.gateway --data design
design (gpt-4.1-mini-2025-04-14): 456 runs through the gateways | no limit
model calls answered 13,269 | cost US$13.73 (recorded runs to their end: US$13.73, saved US$0.00)
runaway 32 runs, 0 stopped | US$4.52 of US$4.52
success 200 runs, 0 stopped | US$3.24 of US$3.24
failure 224 runs, 0 stopped | US$5.97 of US$5.97
successful runs stopped (wrong blocks): 0
same result as the arithmetic (replay/controls.py): yes | 25.0 s

Ce que cela nous apprend. Chacun des 13 269 appels enregistrés a passé la passerelle et a été tarifé. Le total de la passerelle égale le calcul de replay/controls.py, exécution par exécution. Le rejeu fonctionne donc, et rien dans la passerelle n’arrête encore cet agent.

La première idée de Tariq est de copier les limites du flux de soutien de Larkfield dans le cours : 8 appels par exécution et 2 000 000 de jetons par jour.

Fenêtre de terminal
python -m replay.gateway --data design --max-calls-per-run 8 --tokens-per-day 2000000
design (gpt-4.1-mini-2025-04-14): 456 runs through the gateways | step limit 8, quota 2,000,000 tokens a day
model calls answered 289 | cost US$0.21 (recorded runs to their end: US$13.73, saved US$13.53)
runaway 32 runs, 32 stopped | US$0.01 of US$4.52
success 200 runs, 199 stopped | US$0.08 of US$3.24
failure 224 runs, 224 stopped | US$0.12 of US$5.97
successful runs stopped (wrong blocks): 199
first run_step_limit: 429 Run fe7e8ca0-e0dd-446f-9e32-374357c201df has made 8 model calls: the limit is 8. Stop the run and hand the task to a person.
first quota_exhausted: 429 phone-support has used its 2,000,000 tokens for today.
same result as the arithmetic (replay/controls.py): yes | 1.0 s

Ce que cela nous apprend. Cela « économise » 13,53 $ US en arrêtant presque tout : 199 des 200 exécutions réussies. Le flux de Larkfield fait de 1 à 5 appels par exécution; la réussite médiane de cet agent en fait 19. Sa journée utilise 134,5 millions de jetons. Le quota de 2 millions a donc été épuisé après les 36 premières exécutions. Une limite appartient à un seul agent. Elle vient de ses propres exécutions, jamais de l’enregistrement d’un autre agent.

Partie 1 : un nouveau contrôle, la limite de répétition

Section intitulée « Partie 1 : un nouveau contrôle, la limite de répétition »

Pensez à un enfant dans une voiture qui demande « Est-ce qu’on est arrivés? » pour la dixième fois. Chaque question est courte. La répétition indique que quelque chose ne va pas.

L’exécution emballée ci-dessus a fait la même chose : elle a demandé le même outil avec les mêmes arguments 32 fois. Une limite d’étapes compte chaque appel de l’exécution, utile ou non. Une limite de répétition compte seulement le même appel : le même outil avec les mêmes arguments, dans une seule exécution. À la limite, la passerelle d’outils refuse l’appel identique suivant avec 429 repeat_limit (limite de répétition), et l’exécution s’arrête. La passerelle d’outils du cours enregistre déjà une empreinte des arguments de chaque appel. La règle n’a donc besoin d’aucun nouvel enregistrement. Elle compte les lignes de cette exécution avec le même outil et la même empreinte. Le projet l’ajoute devant la passerelle d’outils, dans replay/repeat_rule.py.

La boucle dans tests/test_controls.py est un petit exemple. Elle fait six appels à get_details_by_id(L7). Chaque appel compte 1 000 jetons en entrée et 100 en sortie (0,00015 $ US au prix de chat-small).

Une exécution du même appel, get_details_by_id(L7), cinq fois en colonne. Chaque case montre deux compteurs : appels dans l'exécution et même appel, tous deux à 1, 2, 3, 4. Avec une limite d'étapes de 4, l'appel 5 est refusé avec 429 run_step_limit. Avec une limite de répétition de 2, l'appel d'outil de l'appel 3 est refusé avec 429 repeat_limit, et l'exécution s'arrête après 3 appels.
Deux compteurs sur une boucle, deux réglages. La limite d'étapes compte chaque appel de l'exécution. La limite de répétition compte seulement le même appel et arrête cette boucle plus tôt.
Description textuelle du diagramme

Le même appel cinq fois. Les deux compteurs passent par 1, 2, 3, 4. Une limite d’étapes de 4 refuse l’appel 5. Une limite de répétition de 2 refuse l’appel d’outil de l’appel 3. L’exécution s’arrête après 3 appels de modèle, car le troisième appel a déjà reçu une réponse et a été payé.

Comptez à la main. Avec une limite d’étapes de 4, la passerelle refuse le 5e appel de la boucle. La passerelle a répondu à 4 appels, et la limite en a économisé 2 sur les 6 : 0,0003 $ US. Avec une limite de répétition de 2, la passerelle d’outils refuse le troisième appel d’outil identique. Cela arrive après que la passerelle de modèles a répondu à 3 appels. Quand une limite de répétition se trompe-t-elle? Quand une bonne exécution a vraiment besoin de refaire la même recherche. Par exemple, l’agent revérifie une ligne après que le client a redémarré son téléphone.

replay/controls.py rejoue chaque exécution avec un objet Settings, appel par appel, comme le feraient les passerelles. Deux vérifications manquent dans le code de départ.

  1. Ouvrez replay/controls.py et trouvez le premier TODO (Part 2) (à faire, partie 2). Il se trouve dans la boucle des appels de modèles de l’exécution, avant de compter l’appel. Ajoutez la limite d’étapes :

    if s.max_calls_per_run and o.calls >= s.max_calls_per_run:
    o.stopped_at, o.stopped_by = i, "run_step_limit"
    break

    La passerelle vérifie le compte avant l’appel. Elle refuse donc l’appel qui atteint la limite.

  2. Trouvez le deuxième TODO (Part 2), dans la boucle des appels d’outils. Ajoutez la limite de répétitions :

    if s.repeat_limit and seen.get(key, 0) >= s.repeat_limit:
    o.stopped_at, o.stopped_by = i, "repeat_limit"
    break
  3. Relancez les tests : python -m pytest -q. La dernière ligne indique 14 passed (14 tests réussis).

Les deux tests des passerelles réussissent maintenant aussi. Ils rejouent les premières exécutions d’une journée dans les vraies passerelles et comparent chaque exécution avec vos calculs. Si vous avez écrit > plutôt que >=, les calculs laissent passer un appel de plus que la passerelle. Ces tests échouent alors.

Partie 3 : une comparaison équitable avec une seule mesure

Section intitulée « Partie 3 : une comparaison équitable avec une seule mesure »

replay/compare.py donne à chaque contrôle son réglage le plus strict sans blocage injustifié pendant la journée de référence. Il essaie chaque valeur, de la plus stricte à la plus élevée. Il garde la première qui n’arrête aucune exécution réussie.

Fenêtre de terminal
python -m replay.compare
Each control at its tightest setting that stops no successful run (the measure: US$ saved):
control setting saved runaways stopped failures stopped
step limit (model gateway) 44 calls US$ 3.37 32 of 32 15 of 224
repeat limit (tool gateway) 13 times US$ 3.16 32 of 32 4 of 224
daily quota (model gateway) 135 M tokens US$ 0.00 0 of 32 0 of 224
Strict arguments (always on): 0 tool calls refused (all of them errors in the recording too); 0 runs stopped
Writes need a person: 11 of 32 runaways ever write (first write at call 7, median); 156 of 200 successful runs would wait for a person

Ce que cela nous apprend.

  • La limite d’étapes économise le plus : 3,37 $ US sur 13,73 $ US (25 %). Elle arrête les 32 exécutions emballées et 15 longues exécutions échouées, mais aucune exécution réussie. Son réglage correspond à la plus longue exécution réussie : 44 appels.
  • La limite de répétitions suit de près : 3,16 $ US. Les exécutions réussies répétaient un même appel jusqu’à 13 fois. La limite ne peut donc pas être plus stricte. Les exécutions emballées répétaient un même appel de 23 à 63 fois.
  • Le quota quotidien n’économise rien. Un quota qui n’arrête aucune exécution réussie doit couvrir toute la journée. Un quota compte le travail de l’agent, pas celui d’une seule exécution. Quand il entre en jeu, il arrête aussi les bonnes exécutions qui suivent la boucle.
  • Les arguments stricts n’ont rien arrêté ici. gpt-4.1-mini n’a envoyé aucun argument incorrect. La passerelle d’outils garde cette vérification active pour chaque agent : elle concerne la sécurité, pas les boucles.
  • Les écritures qui exigent une personne ne contiennent pas ces boucles. Seulement 11 des 32 exécutions emballées ont effectué une écriture. Les boucles elles-mêmes sont des lectures. Mais 156 des 200 exécutions réussies attendraient une personne. C’est une décision d’autonomie, comme dans L’autonomie et les approbations sous forme de politiques, pas un contrôle des emballements.

L’échec du quota a un prix. Réglez-le plus bas, à 120 millions de jetons, et rejouez les exécutions :

design (gpt-4.1-mini-2025-04-14): 456 runs through the gateways | quota 120,000,000 tokens a day
model calls answered 11,845 | cost US$12.25 (recorded runs to their end: US$13.73, saved US$1.48)
runaway 32 runs, 4 stopped | US$4.03 of US$4.52
success 200 runs, 23 stopped | US$2.89 of US$3.24
failure 224 runs, 24 stopped | US$5.34 of US$5.97
successful runs stopped (wrong blocks): 23
first quota_exhausted: 429 phone-support has used its 120,000,000 tokens for today.
same result as the arithmetic (replay/controls.py): yes | 21.4 s

Il a économisé 1,48 $ US et arrêté seulement 4 exécutions emballées. Mais il a interrompu l’aide offerte à 23 clients : toutes les exécutions après l’épuisement du quota, bonnes ou mauvaises. Le mois rejoué de Larkfield montrait le même coût d’une limite par agent. La boucle consommait le quota, puis le travail normal était refusé.

456 exécutions enregistrées de gpt-4.1-mini, rejouées dans les passerelles du cours; chaque jeton au prix de chat-small. La journée coûtait 13,73 $ US sans limite.
Description textuelle du graphique

Quatre barres. Limite d’étapes de 44 : 3.37 $ US économisés. Limite de répétitions de 13 : 3.16 $ US. Quota quotidien de 135 millions de jetons : 0.00 $ US. Limite d’étapes choisie de 50, avec une marge : 2.97 $ US. Aucun réglage n’arrête d’exécution réussie de la journée.

La limite d’étapes la plus stricte, 44, correspond à la durée d’une seule exécution : la plus longue réussite d’une journée. Un réglage sans marge au-dessus échoue dès la première bonne exécution plus longue. À quelle vitesse les blocages injustifiés augmentent-ils sous cette limite?

La journée de référence (200 exécutions réussies). Sous 45 appels, chaque baisse de 5 appels arrête davantage d'exécutions réussies.
Description textuelle du graphique

Une courbe des exécutions réussies arrêtées, pour des limites d’étapes de 5 à 100, par pas de 5. À 5 : les 200. À 10 : 173. À 20 : 82. À 30 : 19. À 35 : 8. À 40 : 3. À partir de 45 : aucune.

Tariq choisit 50 appels par exécution : environ 10 % de plus que la plus longue exécution réussie. Ingrid demande ce que coûte cette marge. Ouvrez replay/compare.py, trouvez TODO (Part 4) (à faire, partie 4) et inscrivez votre choix :

chosen = {"max_calls_per_run": 50}

Rejouez ensuite la journée de référence dans les passerelles avec ce réglage :

Fenêtre de terminal
python -m replay.gateway --data design --max-calls-per-run 50
design (gpt-4.1-mini-2025-04-14): 456 runs through the gateways | step limit 50
model calls answered 11,689 | cost US$10.76 (recorded runs to their end: US$13.73, saved US$2.97)
runaway 32 runs, 32 stopped | US$1.72 of US$4.52
success 200 runs, 0 stopped | US$3.24 of US$3.24
failure 224 runs, 11 stopped | US$5.80 of US$5.97
successful runs stopped (wrong blocks): 0
first run_step_limit: 429 Run 767e83fc-50bd-4688-b1b4-ce5f1fc145f6 has made 50 model calls: the limit is 50. Stop the run and hand the task to a person.
same result as the arithmetic (replay/controls.py): yes | 20.5 s

Ce que cela nous apprend. La marge réduit les économies de 0,40 $ US : 2,97 $ US plutôt que 3,37 $ US. Les dépenses des exécutions emballées passent de 4,52 $ US à 1,72 $ US, soit environ 0,05 $ US chacune avant l’arrêt. Chaque exécution emballée reçoit le message de la passerelle, « Stop the run and hand the task to a person » (arrêtez l’exécution et confiez la tâche à une personne), après 50 appels plutôt que 100. Et le résultat de la passerelle correspond aux calculs, exécution par exécution.

Une limite adaptée à un modèle peut ne pas convenir au suivant. Changer le modèle derrière une capacité est une mise en production, comme dans Modifier une association en toute sécurité. Les limites font partie des éléments qui doivent encore réussir les vérifications. Tariq rejoue les exécutions de deux autres modèles avec les réglages recommandés. Il s’agit d’une limite de 50 étapes et d’un quota quotidien de 270 millions de jetons comme plafond. Ce plafond représente environ deux fois la journée de référence.

  1. Rejouez les exécutions de gpt-4.1 :

    Fenêtre de terminal
    python -m replay.gateway --data gpt-4.1 --max-calls-per-run 50 --tokens-per-day 270000000
    gpt-4.1 (gpt-4.1-2025-04-14): 456 runs through the gateways | step limit 50, quota 270,000,000 tokens a day
    model calls answered 7,639 | cost US$6.20 (recorded runs to their end: US$6.43, saved US$0.23)
    runaway 3 runs, 3 stopped | US$0.15 of US$0.38
    success 156 runs, 0 stopped | US$1.87 of US$1.87
    failure 297 runs, 0 stopped | US$4.18 of US$4.18
    successful runs stopped (wrong blocks): 0
    first run_step_limit: 429 Run 2927f14c-f552-43b4-b3b1-96221e1d8eb9 has made 50 model calls: the limit is 50. Stop the run and hand the task to a person.
    same result as the arithmetic (replay/controls.py): yes | 11.9 s
  2. Rejouez les exécutions de o4-mini :

    Fenêtre de terminal
    python -m replay.gateway --data o4-mini --max-calls-per-run 50 --tokens-per-day 270000000
    o4-mini (o4-mini-2025-04-16): 456 runs through the gateways | step limit 50, quota 270,000,000 tokens a day
    model calls answered 8,070 | cost US$8.01 (recorded runs to their end: US$8.01, saved US$0.00)
    runaway 0 runs, 0 stopped | US$0.00 of US$0.00
    success 192 runs, 0 stopped | US$2.81 of US$2.81
    failure 264 runs, 0 stopped | US$5.20 of US$5.20
    successful runs stopped (wrong blocks): 0
    first invalid_arguments (the recording had an error too): 400 Unknown arguments for phone.get_details_by_id: app_name, permission.
    same result as the arithmetic (replay/controls.py): yes | 13.4 s
  3. Ajoutez la limite de 13 répétitions à la reprise des exécutions de o4-mini :

    Fenêtre de terminal
    python -m replay.gateway --data o4-mini --max-calls-per-run 50 --repeat-limit 13
    o4-mini (o4-mini-2025-04-16): 456 runs through the gateways | step limit 50, repeat limit 13
    model calls answered 8,040 | cost US$7.97 (recorded runs to their end: US$8.01, saved US$0.04)
    runaway 0 runs, 0 stopped | US$0.00 of US$0.00
    success 192 runs, 2 stopped | US$2.77 of US$2.81
    failure 264 runs, 1 stopped | US$5.19 of US$5.20
    successful runs stopped (wrong blocks): 2
    first invalid_arguments (the recording had an error too): 400 Unknown arguments for phone.get_details_by_id: app_name, permission.
    first repeat_limit: 429 phone.get_details_by_id with these arguments was called 13 times in run bd003cad-f451-4c8f-bbb9-1d50f355d66b: the limit is 13. Stop the run and hand the task to a person.
    same result as the arithmetic (replay/controls.py): yes | 14.1 s

Ce que cela nous apprend.

  • La limite de 50 étapes a tenu pour les deux modèles : aucun blocage injustifié. Elle a arrêté les 3 exécutions emballées de gpt-4.1 à la moitié de leur coût. o4-mini n’avait aucune exécution emballée, donc la limite n’a rien coûté.
  • La marge a compté. La plus longue exécution réussie de chacun des deux nouveaux modèles a fait 45 appels. Le réglage le plus strict de la journée de référence, 44, aurait arrêté une bonne exécution de chacun.
  • La limite de répétitions ne s’est pas transférée. Les exécutions réussies de o4-mini répétaient un même appel jusqu’à 26 fois. Une limite de 13 répétitions en a donc arrêté 2. Une règle qui suit les habitudes d’un modèle ne tient plus quand le modèle change.
  • Les arguments stricts ont fait refuser 25 appels d’outils de o4-mini. Par exemple, get_details_by_id recevait des arguments que l’outil n’a pas. Les outils du banc d’essai les ont tous refusés aussi. Aucune exécution n’a donc changé. La passerelle transmet l’erreur à l’agent avant que le serveur d’outils voie l’appel.

Tariq la rédige pour qu’Ingrid la révise, dans ses mots à elle :

Cinq lignes : un risque, puis son contrôle. Une boucle dans la même exécution : une limite de 50 appels par exécution à la passerelle de modèles, qui arrête l'exécution et la confie à une personne. Une boucle qui lance une nouvelle exécution pour chaque appel : un quota quotidien de 270 millions de jetons à la passerelle de modèles, un plafond pour tout l'agent. La même recherche répétée : un compte des répétitions tiré des relevés d'utilisation, une alerte au responsable, pas un arrêt. Un appel d'outil incorrect ou inconnu : des outils enregistrés et des arguments stricts à la passerelle d'outils, toujours actifs. Une écriture qui modifie le compte du client : la politique d'approbation à la passerelle d'outils, décidée selon le risque, pas pour les emballements.
Chaque risque a son propre contrôle. Seules la limite d'étapes et le quota imposent des arrêts aux boucles; le compte des répétitions est une alerte.
Description textuelle du diagramme

Une boucle dans une exécution : une limite de 50 appels à la passerelle de modèles, qui confie le client à une personne. Une boucle avec une nouvelle exécution pour chaque appel : un quota quotidien de 270 millions de jetons. La même recherche répétée : un compte des répétitions, comme alerte. Un appel d’outil incorrect ou inconnu : des outils enregistrés et des arguments stricts, toujours actifs. Une écriture dans le compte du client : la politique d’approbation, selon le risque.

  1. Enregistrez l’agent avec une limite de 50 appels de modèles par exécution. Pendant la journée rejouée, elle a arrêté les 32 boucles à la moitié de leur coût. Elle n’a arrêté aucune conversation réussie et a économisé 2,97 $ US sur 13,73 $ US à notre prix.
  2. Fixez un quota quotidien comme plafond, pas comme contrôle des emballements. Environ deux fois une journée normale : 270 millions de jetons selon les chiffres de la journée rejouée. Il vise la boucle que la limite d’étapes ne peut pas voir : un agent qui relance une exécution après chaque erreur. Un quota assez strict pour arrêter les boucles aurait interrompu 23 bonnes conversations.
  3. Surveillez les appels répétés, sans les arrêter. Alertez le responsable quand une exécution fait le même appel plus de 13 fois. Comme arrêt obligatoire, la règle a échoué avec le modèle suivant.
  4. Gardez les arguments stricts et la liste des outils enregistrés actifs. Ils ne coûtent rien sur ces données et arrêtent les appels incorrects avant qu’ils atteignent un système.
  5. Mesurez de nouveau après le lancement et à chaque changement de modèle. Ces limites viennent d’un agent de banc d’essai avec des clients simulés. Après les premières semaines, rejouez les propres exécutions de l’agent à partir des relevés d’utilisation. Modifiez l’enregistrement si les plus longues bonnes exécutions approchent de 50.

Ce à quoi les limites ne servent pas : elles ne font pas réussir une conversation échouée. Les 224 exécutions échouées coûtaient 5,97 $ US, plus que les exécutions emballées. La limite d’étapes n’en a arrêté que 11. Les échecs sont un problème de qualité : évaluez l’agent, comme dans Évaluer et tester les systèmes d’IA, et corrigez sa requête ou ses outils.

  • Les données déterminent la limite. Les limites de Larkfield ont arrêté 199 des 200 bonnes exécutions de cet agent. Une limite est un nombre dans l’enregistrement d’un agent, mesuré sur cet agent.
  • Un écart rend une limite d’étapes peu coûteuse. Ici, la plus longue réussite faisait 44 appels et la plus courte exécution emballée, 77. Sans écart, chaque réglage échange des économies contre des blocages injustifiés. La comparaison doit attribuer un prix aux deux.
  • Un quota par agent est un plafond. Il ne distingue pas une boucle d’une journée chargée. Il protège le budget, pas les clients.
  • Une journée, un domaine, un banc d’essai. 114 tâches, chacune exécutée 4 fois, avec un modèle comme client. Les vrais clients sont plus variés. L’ordre de la journée est construit : les chiffres du quota en dépendent, mais pas les limites d’étapes et de répétitions.
  • La reprise s’arrête à la première réponse différente. Après un refus, un vrai agent pourrait se reprendre ou essayer une troisième voie. La reprise ne peut pas le savoir. Elle compte donc l’exécution comme arrêtée.
  • Décrivez les données honnêtement. Ce sont des exécutions de banc d’essai d’autres modèles, facturées à notre prix. Présentez les limites comme un point de départ tiré de données publiques, pas comme des mesures de votre propre agent.
  • Un arrêt doit bien transférer la tâche. Le message de la passerelle dit « hand the task to a person » (confiez la tâche à une personne). Dans une conversation avec un client, une personne doit recevoir la conversation et le client doit être informé, pas laissé en attente. Testez ce parcours avant le lancement.
  • Gardez les renseignements du client hors des relevés. Le stockage d’utilisation conserve une empreinte des arguments de chaque appel d’outil, pas leurs valeurs. Cela suffit pour compter les répétitions. N’ajoutez pas les valeurs pour mieux voir les boucles.
  • Citez la source. Les données sont sous licence MIT. Conservez le texte de la licence et l’attribution dans votre copie, comme le fait la fiche du jeu de données.

Ce projet montre ce que les équipes de plateforme recherchent. Les limites viennent de preuves, les deux erreurs sont comptées, de nouvelles entrées vérifient le choix, et de vrais contrôles exécutent la reprise.

Quoi mettre dans le dépôt :

runaway-replay/
README.md the question, how to run it, the results table and the recommendation
data/dataset.md the source, the licence, the checksums, the changes, the limits
data/trajectories/ the fixed sample and the τ²-bench licence text
LICENSE MIT, for your code
replay/ data, controls, compare, the stand-in provider, the repeat rule, the gateway replay
tests/ 14 tests
results/ your compare.json and the replay outputs
  1. Créez un nouveau dépôt Git à partir de votre dossier de projet et poussez-le sur GitHub. .gitignore exclut results/ : ajoutez les fichiers que vous voulez montrer avec git add -f.
  2. Rédigez le tableau des résultats du README à partir de votre propre sortie de python -m replay.compare. Incluez la référence de base et la vérification sur de nouvelles entrées.
  3. Indiquez dans le README que la reprise exige le projet du cours (ESTATE_PROJECT). Précisez que python -m pytest réussit quand ce projet est présent.

En deux phrases, pour une entrevue :

« J’ai rejoué 456 exécutions enregistrées publiques d’un agent de soutien d’IA dans une passerelle de modèles et une passerelle d’outils, pour choisir ses limites. Une limite de 50 appels a arrêté toutes les boucles à la moitié de leur coût, sans arrêter de bonne conversation, même avec deux autres modèles. »

Allez plus loin : le projet contient aussi les 456 exécutions de Claude 3.7 Sonnet. Rejouez-les avec --data claude-3.7-sonnet et lisez les refus tool_not_allowed (outil non autorisé). Ce modèle appelait les outils du téléphone du client, que l’agent n’a pas. Ou réduisez un autre fichier de résultats du banc d’essai avec python -I tools/make_sample.py, dans un nouveau dossier vide. Ou attribuez un prix à un blocage injustifié, soit le temps d’une personne par conversation. Choisissez ensuite la limite d’étapes qui donne le coût total le plus bas.

Vérifiez votre compréhension

Le flux de travail de Larkfield utilise une limite de 8 appels par exécution, qui fonctionne bien dans ce contexte. Pourquoi cette même limite a-t-elle arrêté 199 des 200 exécutions réussies de l'agent de téléphone?

Afficher la réponse

Une limite appartient à un agent et à son travail. Le flux de travail de Larkfield fait de 1 à 5 appels par exécution. Une limite de 8 laisse donc une marge. L’exécution réussie médiane de l’agent de téléphone fait 19 appels, et la plus longue, 44. Une limite d’étapes doit venir des propres exécutions de l’agent : ici, un peu au-dessus de 44. Dans la reprise, le quota de 2 000 000 de jetons s’est aussi épuisé après 36 exécutions. L’agent utilise environ 134,5 millions de jetons par jour.

Vérifiez votre compréhension

La limite d'étapes sûre la plus stricte pour la journée de référence était de 44 appels. Elle économisait plus que 50. Pourquoi Tariq a-t-il recommandé 50, et qu'ont montré les nouvelles entrées?

Afficher la réponse

44 correspond à la durée d’une seule exécution, la plus longue réussite d’une journée. Un réglage sans marge au-dessus échoue dès la première bonne exécution plus longue. La marge a réduit les économies de 0,40 $ US pendant la journée de référence. Sur les nouvelles entrées, les plus longues exécutions réussies de gpt-4.1 et de o4-mini faisaient toutes deux 45 appels. Une limite de 44 aurait arrêté une bonne exécution de chacun. Une limite de 50 n’en a arrêté aucune.

Vérifiez votre compréhension

Ingrid demande : « Pourquoi ne pas utiliser seulement le quota quotidien? C'est un seul nombre, et il protège le budget. » Que répond la reprise?

Afficher la réponse

Un quota compte toute la journée de l’agent, pas une seule exécution. Un quota qui n’arrête aucune bonne exécution doit couvrir la journée, soit environ 135 millions de jetons. Il n’économisait alors rien. À 120 millions, il économisait 1,48 $ US et arrêtait seulement 4 exécutions emballées. Mais il interrompait 23 conversations réussies : toutes les exécutions après l’épuisement du quota. Gardez le quota comme plafond, à environ deux fois une journée normale, et contenez les boucles avec la limite d’étapes.

Récapitulatif

  • Les exécutions enregistrées d’un agent semblable peuvent servir à fixer ses limites avant le lancement. Rejouez-les dans les passerelles. Comptez ce que chaque contrôle économise et quelles bonnes exécutions il arrête.
  • Sur 456 exécutions d’un agent de soutien ouvert, les emballements représentaient 7 % des exécutions et un tiers du coût. Une limite de 50 étapes a arrêté les 32 à la moitié de leur coût, sans arrêter d’exécution réussie.
  • Les limites d’un autre agent ont arrêté 199 des 200 bonnes exécutions. Un quota par agent n’économisait rien sans interrompre l’aide aux clients. Une limite de répétitions fonctionnait avec un modèle et échouait avec le suivant.
  • Choisissez avec une marge et vérifiez de nouveau sur de nouvelles entrées. La plus longue bonne exécution du modèle suivant dépassait d’un appel le réglage le plus strict.

Vous pouvez maintenant choisir les limites d’un agent à partir de preuves et les défendre lors d’une révision. Mais un enregistrement liste aussi les outils et les serveurs qu’un agent peut utiliser. Beaucoup d’équipes veulent des serveurs MCP publics. Ensuite, vous examinez des serveurs MCP publics pour les enregistrer, à partir de leurs seules informations publiées.

Leçon suivante : Examiner des serveurs MCP publics pour les enregistrer