Le coût d'un agent de programmation
- Étude de cas 2
- 150 min
- Facultative · 1 étude de cas requise pour le certificat
Où nous en sommes
Dans le module sur le coût, nous avons réparti le coût du flux de travail de Larkfield par exécution, étape, modèle et groupe. Un agent de programmation fait beaucoup plus d'étapes. Son coût dépend encore davantage du chemin qu'il suit. Dans cette étude de cas, nous mesurons le coût d'exécutions ouvertes d'agents de programmation. Nous proposons ensuite un budget et une limite d'étapes.
Étude de cas 2 sur 3 · Observabilité des agents d'IA : traces, coûts et pistes d'auditLe coût d'un agent de programmation
1. Pourquoi les agents ont besoin de leur propre observabilité
2. OpenTelemetry pour les agents
3. Instrumenter le flux de travail
4. Trouver les défaillances des agents dans Grafana
5. Le coût
6. Pistes d'audit
7. Alertes, niveaux de service et qualité
8. Outils : Langfuse, les autres et l'inspecteur d'exécutions
Ce que vous saurez faire
Mesurez le coût d’un agent de programmation par tâche, par appel de modèle et par résultat. Utilisez 445 exécutions enregistrées d’un agent ouvert. Trouvez les exécutions qui bouclent ou dépensent trop. Choisissez une limite d’étapes, une alerte et un budget à partir des observations. Vérifiez ensuite votre choix sur 445 exécutions du même agent avec un autre modèle.
Cette étude de cas est un dossier de projet, pas un carnet (notebook) Jupyter. Il est petit (environ 1 Mo), utilise seulement la bibliothèque standard de Python et s’exécute dans l’environnement virtuel du projet du cours. À une étape, l’outil obs du cours lit les exécutions de l’étude de cas. Le dossier se trouve donc à côté du projet du cours.
Avant de commencerCe qu’il faut savoir et avoir sous la main
Ce que vous devez savoir
Cette étude de cas utilise surtout le module sur le coût :
- Les jetons multipliés par une table de prix datée, dans Coût par exécution et par étape.
- Le coût par billet de soutien résolu, et pourquoi une répartition doit inclure le résultat, dans Coût par client, par agent, par locataire et par modèle.
- Une alerte budgétaire qui nomme ses exécutions, et la limite dans le code qui arrête les dépenses, dans Budgets, alertes et l’exécution coûteuse.
- Les attributs de jetons d’un span (une opération enregistrée)
chat, dans Appels de modèle et jetons. - Le modèle de boucle, dans Les modèles de défaillance des agents.
Cette page enseigne une nouvelle idée : chaque appel d’un agent de programmation renvoie tout l’historique. Le cache du fournisseur change son prix.
Ce qu’il vous faut sur votre ordinateur
- Le projet du cours à la fin du cours, dans
~/projects/observable-workflow, avec son environnement virtuel. Si le vôtre ne fonctionne plus, téléchargez l’instantanéend-of-m08et suivez son README. - Environ 2 Mo d’espace disque. Aucun compte, aucune clé et aucune dépense : chaque nombre de jetons vient d’un enregistrement.
Testé sur macOS (Apple silicon) avec Python 3.12.13. Les commandes Windows (PowerShell) et Linux sont écrites, mais n’ont pas été exécutées.
La situation
Section intitulée « La situation »Hana (elle) dirige une petite équipe de développement logiciel, inventée pour cette étude de cas. L’équipe a une liste de tâches de maintenance en attente : une compilation défectueuse, un script à porter, un plantage à trouver. Leo (il), un ingénieur de plateforme, veut qu’un agent de programmation y travaille la nuit. L’agent reçoit un terminal dans un nouveau conteneur, une tâche et une limite de temps. Il demande à un modèle quoi faire, exécute les commandes, lit la sortie et pose une nouvelle question. Le matin, un test indique si la tâche est terminée.
Hana doit donner un chiffre au service des finances avant l’essai. Elle pose trois questions à Leo :
- Combien coûte une tâche, et combien coûte une tâche résolue?
- Quelles exécutions gaspillent de l’argent, et comment les repérer?
- Qu’est-ce qui arrête une exécution qui tourne mal à 3 h du matin, et quel budget surveillons-nous?
Chaque mauvaise réponse a un prix. Une limite trop souple laisse une boucle dépenser toute la nuit. Une limite trop stricte arrête une exécution qui allait réussir son test. Un ingénieur fait alors cette tâche à la main. Cela coûte beaucoup plus cher que n’importe quel appel de modèle.
L’équipe n’a pas encore ses propres exécutions. Leo mesure donc des exécutions enregistrées d’un agent de programmation ouvert sur des tâches publiques, avec les outils de coût du cours. Après le lancement, l’équipe devra vérifier ces chiffres avec ses propres exécutions.
Ce que vous allez créer
Section intitulée « Ce que vous allez créer »Vous allez créer un rapport de coûts et une recommandation de limites pour un agent de programmation, à partir d’exécutions enregistrées. Vous complétez le calcul du coût d’une étape, le comparez à l’enregistrement et explorez où va l’argent. Vous complétez ensuite les limites et en comparez trois avec une seule mesure. Vous choisissez une limite d’étapes, une alerte et un budget. Enfin, vous refaites toute la vérification sur le même agent avec un autre modèle.
Préparer le projet
Section intitulée « Préparer le projet »-
Téléchargez le projet de départ dans l’encadré en haut de cette page. Décompressez-le dans
~/projects, pour placer le dossiercoding-agent-costà côté deobservable-workflow. -
Dans VS Code, choisissez File > Open Folder (fichier : ouvrir un dossier), puis ouvrez
coding-agent-cost. Ouvrez ensuite un terminal : Terminal > New Terminal (terminal : nouveau terminal). -
Activez l’environnement virtuel du projet du cours :
Fenêtre de terminal source ../observable-workflow/.venv/bin/activateFenêtre de terminal ..\observable-workflow\.venv\Scripts\Activate.ps1Fenêtre de terminal source ../observable-workflow/.venv/bin/activate -
Exécutez les tests :
python -m pytest -q. Le projet de départ contient deux parties à compléter, donc six tests échouent :FAILED tests/test_cost.py::test_a_step_by_hand - assert 0.0030100000000000005...FAILED tests/test_cost.py::test_our_price_table_gives_every_recorded_cost - A...FAILED tests/test_limits.py::test_a_step_limit_of_4_lets_4_calls_through - As...FAILED tests/test_limits.py::test_a_stopped_solved_run_is_a_wrong_block - Ass...FAILED tests/test_limits.py::test_a_cost_limit_is_checked_before_the_call_so_the_run_ends_over_itFAILED tests/test_limits.py::test_the_measure_counts_both_errors - assert (1 ...6 failed, 10 passed in 0.90sUn test lit les exécutions de l’étude de cas avec l’outil
obsdu cours. Si votre projet du cours est ailleurs, définissezOBS_PROJECTavec ce dossier. Sinon, pytest ignore le test.
Le projet terminé se trouve dans le même encadré, pour le comparer à votre travail. Toutes les sorties de cette page en proviennent.
Les données
Section intitulée « Les données »Les données sont les exécutions publiées de Terminal-Bench 2.0, un banc d’essai ouvert d’agents d’IA qui travaillent dans un terminal. Ses 89 tâches sont des travaux d’ingénierie : compiler un compilateur, corriger un plantage, porter un script, entraîner un petit modèle. Un test décide si la tâche est terminée. L’agent du banc d’essai, Terminus 2, a exécuté chaque tâche 5 fois avec de nombreux modèles.
Leo avait besoin des jetons de chaque appel de modèle, des commandes, de la fin de chaque exécution et de vraies boucles. Les exécutions ouvertes de SWE-agent, SWE-smith et OpenHands ne contiennent aucun nombre de jetons, ou seulement un total par exécution. C’est ce qu’a constaté l’étude de cas du cours Gouverner les agents d’IA : passerelles, registres et contrôles. Terminal-Bench enregistre les jetons de chaque appel et la partie en cache. Pour certains modèles, il enregistre aussi le coût calculé par le programme d’exécution.
L’échantillon de conception comprend 445 exécutions de Terminus 2 avec DeepSeek-V3.2, un modèle peu coûteux. Nous choisissons les limites sur cet échantillon. Les 445 exécutions du même agent avec Claude Opus 4.6 sont les nouvelles données utilisées à la fin. Une exécution contient ces champs :
| Champ | Son contenu |
|---|---|
id, task |
l’exécution (nom de tâche et code d’essai); une des 89 tâches, chacune exécutée 5 fois |
reward, exception |
sa fin : les tests ont réussi (solved, résolue), échoué (failed, échouée), ou l’agent a d’abord atteint la limite de temps de la tâche (timed_out, délai dépassé) |
steps[].prompt, cached, completion |
un appel de modèle : jetons d’entrée (ceux en cache inclus), partie en cache, jetons de sortie |
steps[].cost |
le coût enregistré par le logiciel d’exécution pour l’appel, lorsqu’il l’a enregistré |
steps[].programs, digests |
le premier mot de chaque commande et une courte empreinte SHA-256 de ses frappes exactes |
Premières vérifications
Section intitulée « Premières vérifications »agentcost/data.py vérifie le SHA-256 de chaque fichier avant de le lire. Après la partie 1 ci-dessous, python -m agentcost check affiche :
terminus2-claude-opus-4.6.jsonl.gz SHA-256 okterminus2-deepseek-v3.2.jsonl.gz SHA-256 okdeepseek: 445 runs of deepseek-chat (89 tasks), 10,966 model calls, 295,559,649 tokens in (286,105,280 cached), 7,001,540 outoutcomes: solved 176, failed 183, timed_out 85, error 1model calls with 0 input tokens recorded: 0recorded cost on 10,966 calls: US$13.60; our price table: US$13.60 (10,966 calls equal to the recorded cost, +0.0% in all)price table 2026-10-23: DeepSeek-V3.2 (deepseek-chat) US$0.28 in, US$0.028 cached in, US$0.42 out per 1M tokensCe que cela nous apprend.
- L’agent a résolu 176 exécutions sur 445 (39,6 %) de tâches difficiles. Une exécution s’est terminée par une erreur du banc d’essai; nous la comptons comme
error(erreur). - 97 % des jetons d’entrée provenaient du cache. Gardez ce chiffre en tête : il détermine la majeure partie de la facture.
- Notre table de prix reproduit exactement tous les coûts enregistrés, pour les 10 966 appels. Et une surprise : la page de prix de DeepSeek ne présente plus ce modèle.
prices.jsonconserve les prix payés par ces exécutions, dans sa propre version. La page d’un fournisseur évolue; un ancien rapport doit conserver ses chiffres. - Aucun appel n’enregistre 0 jeton d’entrée. Le fichier d’un autre modèle du même classement enregistre 0 pour chaque appel. Un zéro enregistré ne signifie pas une exécution gratuite. Nous n’avons donc pas utilisé ce fichier.
Définir le problème
Section intitulée « Définir le problème »L’unité est une exécution : une tentative de l’agent sur une tâche. Le résultat est celui du test. Le « coût par tâche résolue » est le coût par billet résolu de cette étude de cas.
Le prix vient de la table de prix du projet, prices.json, version du 23 octobre 2026. Par million de jetons : 0,28 $ US en entrée, 0,028 $ US en entrée en cache et 0,42 $ US en sortie. Ces prix sont des hypothèses datées : vérifiez les prix actuels de votre fournisseur.
Les deux erreurs d’une limite. Une limite qui arrête une exécution qui aurait résolu sa tâche est un blocage injustifié. Une limite qui n’arrête jamais une boucle laisse l’argent s’en aller. Nous choisissons la mesure dans la partie 3, après avoir vu où va l’argent.
La règle de relecture. Un enregistrement montre ce que l’agent a fait sans être arrêté. Quand une limite arrête une exécution, la relecture s’arrête là : l’exécution n’est pas résolue, et une personne reçoit sa tâche.
Une nouvelle idée : chaque appel paie pour tout l’historique
Section intitulée « Une nouvelle idée : chaque appel paie pour tout l’historique »Imaginez une réunion où, avant chaque nouveau point, quelqu’un lit tout le compte rendu à voix haute depuis le début. Le premier point est rapide. Au vingtième, la lecture occupe la majeure partie de la réunion. Une personne qui possède une copie de l’ancien compte rendu accélère les choses, mais la copie est quand même lue.
Les appels de modèle d’un agent de programmation fonctionnent comme cette réunion. Un modèle n’a aucune mémoire entre les appels. Chaque appel envoie donc les instructions, la tâche et tout ce qui précède : chaque réponse précédente et chaque sortie du terminal. L’entrée d’un appel augmente à chaque étape. Une longue exécution paie son historique encore et encore. De nombreux fournisseurs gardent un cache de requêtes. Quand le début d’une requête correspond à celui d’une requête récente, ils récupèrent cette partie du cache et facturent moins. DeepSeek facture un jeton en cache au dixième du prix d’entrée. Un jeton en cache coûte moins cher, mais il n’est pas gratuit.
Description textuelle du diagramme
Le premier appel de l’exécution envoie 830 jetons. Chaque appel suivant envoie tous les appels précédents, leurs réponses et la sortie du terminal. À l’appel 135, l’entrée compte 115 291 jetons, dont 115 136 proviennent du cache. Cet appel coûte 0,0034 $ US. La nouvelle entrée compte 155 jetons à 0,28 $ US par million. L’entrée en cache compte 115 136 jetons à 0,028 $ US par million. La sortie compte 215 jetons à 0,42 $ US par million.
Calculez l’appel 135 à la main, en millionièmes de dollar. La nouvelle entrée coûte 155 × 0,28 = 43. L’entrée en cache coûte 115 136 × 0,028 = 3 224. La sortie coûte 215 × 0,42 = 90. Presque tout le coût de 0,0034 $ US vient de l’historique en cache. Sans le cache, l’appel coûterait 0,0324 $ US, soit dix fois plus.
Partie 1 : compléter le coût d’une étape
Section intitulée « Partie 1 : compléter le coût d’une étape »-
Exécutez
python -m agentcost checkdans le projet de départ. Sa sixième ligne montre le problème :recorded cost on 10,966 calls: US$13.60; our price table: US$85.70 (27 calls equal to the recorded cost, +530.2% in all)Le projet de départ facture chaque jeton d’entrée au plein prix : la facture sans cache.
-
Ouvrez
agentcost/prices.pyet trouvezTODO (Part 1)(à faire, partie 1) dansstep_cost. Remplacez sa lignereturnpar :cached = step.cached_tokens if cache else 0uncached = step.prompt_tokens - cachedreturn (uncached * p["input"] + cached * p["cached_input"] + step.completion_tokens * p["output"]) / 1e6prompt_tokensinclut les jetons en cache, commegen_ai.usage.input_tokensdans les conventions GenAI. -
Exécutez de nouveau
python -m agentcost check. La ligne indique maintenant10,966 calls equal to the recorded cost(10 966 appels égaux au coût enregistré), comme ci-dessus. Les deux tests de la partie 1 réussissent.
L’outil du cours lit les mêmes exécutions
Section intitulée « L’outil du cours lit les mêmes exécutions »Le projet peut écrire les exécutions sous forme de traces OpenTelemetry, dans le format de fichier du Collector du cours. Chaque exécution reçoit un span invoke_agent, un span chat par appel de modèle et un span execute_tool par commande. Les noms des jetons suivent les conventions GenAI (gen_ai.usage.input_tokens, gen_ai.usage.cache_read.input_tokens). Le coût, l’étape et le résultat utilisent les noms du projet du cours. Ainsi, obs les lit sans changement.
-
Écrivez les traces :
python -m agentcost export.Wrote 445 traces to work/telemetry/deepseek/traces.jsonl.gz (1.4 MB, 45,095 spans), no limit, price table 2026-10-23Read them with the course's obs, in ../observable-workflow: python -m obs cost --by outcome --data ../coding-agent-cost/work/telemetry/deepseek -
Dans un deuxième terminal, dans
~/projects/observable-workflow, avec son environnement actif, exécutez la commande affichée par l’exportation :outcome runs resolved cost US$ per run per resolved successerror 1 0 0.0374 0.03738 - 0.0%failed 183 0 5.8051 0.03172 - 0.0%resolved 176 176 2.4986 0.01420 0.01420 100.0%timed_out 85 0 5.2577 0.06186 - 0.0%total 445 176 13.5988 0.03056 0.07727 39.6% -
Lisez une courte exécution sous forme de cascade :
python -m obs trace openssl-selfsigned-cert__4n5TDfS --data ../coding-agent-cost/work/telemetry/deepseek. Elle montre 8 spanschatavec leurs coûts, et un span par commande.
Ce que cela nous apprend. Un outil écrit pour un autre flux de travail retrouve le même total au cent près : 13,5988 $ US. Il trouve aussi 0,07727 $ US par tâche résolue. Enregistrez une seule fois, avec des noms standard, et n’importe quel outil peut répondre. Mais obs trace affiche aussi Flag no_action: closed as resolved with no write and no reply sent (signalement no_action : fermé comme résolu sans écriture ni réponse envoyée). Cette règle appartient à Larkfield : un billet résolu exige un remboursement ou une réponse. Une règle de signalement appartient à un flux de travail, comme une limite.
Explorer ce que la décision exige
Section intitulée « Explorer ce que la décision exige »Où va l’argent, selon le résultat
Section intitulée « Où va l’argent, selon le résultat »python -m agentcost cost --by outcomeoutcome runs solved steps cost US$ share per run per solved successsolved 176 176 14.5 2.4986 18% 0.0142 0.0142 100.0%failed 183 0 21 5.8051 43% 0.0317 - 0.0%timed_out 85 0 30 5.2577 39% 0.0619 - 0.0%error 1 0 33 0.0374 0% 0.0374 - 0.0%total 445 176 19 13.5988 100% 0.0306 0.0773 39.6%(steps = the median number of model calls per run)Ce que cela nous apprend. Une exécution réussie coûte 0,0142 $ US, mais une tâche résolue coûte 0,0773 $ US. Les exécutions échouées et celles qui dépassent le temps limite font partie de son prix. Seulement 18 % de l’argent a servi à résoudre des tâches. Une exécution qui dépasse le temps limite coûte quatre fois plus qu’une exécution réussie. Avec --no-cache (sans cache), le total serait de 85,70 $ US plutôt que de 13,60 $ US. Le cache divise la facture par 6,3.
Où va l’argent, selon la longueur de l’exécution
Section intitulée « Où va l’argent, selon la longueur de l’exécution »Description textuelle du graphique
Sept barres, selon le nombre d’appels de modèle par exécution. Exécutions de 1 à 10 appels : 87 exécutions, 63 réussies, 3 % des dépenses. De 11 à 20 appels : 157 exécutions, 17 %. De 21 à 30 : 19 %. De 31 à 40 : 17 %. De 41 à 50 : 24 exécutions, 1 réussies, 11 %. De 51 à 100 : 25 exécutions, 1 réussies, 16 %. Plus de 100 : 5 exécutions, aucune réussie, 17 %.
Ce que cela nous apprend. Les exécutions courtes coûtent peu et réussissent souvent : 63 des 87 exécutions ayant au plus 10 appels. Après 40 appels, l’agent ne réussit presque jamais : 2 exécutions sur 54. Ces 54 exécutions représentent 12 % des exécutions, mais 44 % des dépenses. La longueur de l’exécution détermine où va l’argent.
Une longue exécution, appel par appel
Section intitulée « Une longue exécution, appel par appel »L’exécution la plus coûteuse tente de corriger un plantage dans l’environnement d’exécution d’un langage (fix-ocaml-gc). Les 5 exécutions de cette tâche ont échoué. Elles représentent 16 % du coût de l’échantillon.
python -m agentcost steps fix-ocaml-gc__PB7o5ME --every 30fix-ocaml-gc__PB7o5ME: task fix-ocaml-gc, deepseek-chat, timed_out, 307 model calls, US$0.8696 step tokens in cached out cost US$ so far kind commands 1 830 768 265 0.00015 0.0002 work ls cat 30 26,334 25,216 215 0.00111 0.0205 work sed grep grep 60 62,531 62,080 421 0.00204 0.0739 work grep find 90 86,831 86,528 268 0.00262 0.1454 work grep awk grep 120 103,712 103,424 236 0.00308 0.2310 work awk cat 150 116,702 116,672 36 0.00329 0.3306 none - 180 118,540 118,464 36 0.00335 0.4303 none - 210 120,377 120,320 36 0.00340 0.5316 none - 240 122,215 122,176 36 0.00345 0.6344 none - 270 124,052 123,968 36 0.00351 0.7387 none - 300 125,890 125,824 36 0.00356 0.8447 none - 307 126,316 126,272 41 0.00357 0.8696 none -- Jetons reçus
- Jetons reçus depuis le cache
Description textuelle du graphique
Deux courbes couvrent les 307 appels de modèle d’une exécution. L’entrée passe de 830 jetons au premier appel à environ 115 000 à l’appel 135. Elle augmente ensuite lentement jusqu’à 126,316 au dernier appel. Les jetons en cache suivent la même courbe, un peu en dessous : presque toute l’entrée vient du cache.
Ce que cela nous apprend. Le premier appel a coûté 0,00015 $ US; le dernier, 0,00357 $ US, soit 24 fois plus pour une réponse semblable. À partir de l’appel 135, le modèle a répondu 173 fois de suite sans commande. La colonne kind (type) indique none (aucun). Nous avons lu l’enregistrement original de cette exécution. Le modèle y écrit qu’il ne peut pas corriger le bogue. Il répète ensuite un résumé jusqu’au temps limite de la tâche. Ces 173 appels ont coûté 0,59 $ US, soit 68 % du coût de l’exécution. Le cache a limité le coût : sans lui, cette seule exécution aurait coûté 8,28 $ US.
Étapes inactives
Section intitulée « Étapes inactives »La règle de détection des boucles du cours ne peut pas repérer ce comportement. Elle compte les appels au même outil avec les mêmes arguments. Ici, le modèle n’appelle aucun outil. Le projet considère une étape comme inactive quand le terminal ne reçoit rien de nouveau à faire. La réponse ne contient aucune commande, seulement des commandes vides (l’agent attend), ou les mêmes commandes qu’à l’étape précédente. Une étape inactive est souvent normale, par exemple pendant l’attente d’une installation. Une longue série d’étapes inactives est une boucle.
python -m agentcost idleoutcome runs longest idle streak: median maxsolved 176 2 8failed 183 2 8timed_out 85 0 173error 1 2 2The 8 runs with the longest idle streak:run outcome steps cost US$ streak from kind streak US$fix-ocaml-gc__PB7o5ME timed_out 307 0.8696 173 135 none 0.5917fix-ocaml-gc__WB7L8Nf timed_out 240 0.6388 154 83 none 0.4831custom-memory-heap-crash__exMxSPi timed_out 168 0.1823 85 33 none 0.0840fix-ocaml-gc__G9if5xy timed_out 166 0.3827 55 69 none 0.1846crack-7z-hash__Sykdxfk timed_out 63 0.0462 17 47 none 0.0144path-tracing-reverse__nEW2gSJ timed_out 61 0.1528 14 48 none 0.0442train-fasttext__bJf9npe timed_out 85 0.0886 10 32 wait 0.0088rstan-to-pystan__fDESBRy timed_out 55 0.0800 10 33 wait 0.0166Ce que cela nous apprend. Aucune exécution réussie n’avait plus de 8 étapes inactives de suite. Six exécutions en avaient 14 ou plus. Toutes ont dépassé le temps limite, et la plupart n’avaient aucune commande. Les séries d’étapes inactives distinguent donc les boucles du travail pour cet agent. Nous verrons si cela tient avec un autre modèle.
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 l’échantillon de conception sans limite : 13,60 $ US, et 0,0773 $ US par tâche résolue. La première idée de Leo est de copier les limites du flux de soutien de Larkfield présenté dans le cours. Ce sont 8 appels de modèle et 0,05 $ US par exécution.
python -m agentcost limits --max-steps 8 --max-cost 0.05deepseek (deepseek-chat): 445 runs | step limit 8, cost limit US$0.05 (checked before each model call)recorded outcome runs stopped cost US$ of US$solved 176 146 0.8986 2.4986failed 183 172 1.0602 5.8051timed_out 85 84 0.4587 5.2577error 1 1 0.0054 0.0374cost US$2.4229 (no limit: US$13.5988, saved US$11.1759) | solved 30 of 176 | solved runs stopped (wrong blocks): 146cost per solved task: US$0.0808 (no limit: US$0.0773)Ce que cela nous apprend. Cette limite « économise » 11,18 $ US en arrêtant presque tout : 146 des 176 exécutions réussies. Le coût par tâche résolue a augmenté, à 0,0808 $ US. L’argent dépensé pour les exécutions arrêtées n’a rien produit. Le flux de Larkfield fait de 1 à 5 appels par billet de soutien. L’exécution réussie médiane de cet agent en fait 15. Une limite appartient à un agent, et elle vient des exécutions de cet agent.
Partie 2 : compléter les limites
Section intitulée « Partie 2 : compléter les limites »agentcost/limits.py rejoue chaque exécution avec un objet Limits, appel par appel. La vérification est celle de la boucle du cours sur les agents. Avant le prochain appel, arrêtez si l’exécution a fait max_steps appels ou si son coût dépasse max_cost_usd. Le code de départ ne contient pas ces deux vérifications.
-
Ouvrez
agentcost/limits.pyet trouvezTODO (Part 2)(à faire, partie 2) dansreplay. Remplacez le commentaire par :if limits.max_steps and out.steps >= limits.max_steps:out.stopped_by = "max_steps"breakif limits.max_cost_usd and out.cost > limits.max_cost_usd:out.stopped_by = "cost"breakLa vérification vient avant de payer l’appel. Une limite de coût ne peut pas connaître le prix du prochain appel. Une exécution peut donc finir un peu au-dessus.
-
Relancez les tests :
python -m pytest -q. La dernière ligne indique16 passed(16 tests réussis).
La petite exécution dans tests/test_limits.py montre le dépassement : six appels de 0,28 $ US chacun, avec une limite de 0,60 $ US. Après deux appels, l’exécution a dépensé 0,56 $ US, sous la limite. Le troisième appel est donc envoyé. La vérification arrête le quatrième appel, et l’exécution finit à 0,84 $ US.
Partie 3 : une comparaison équitable avec une seule mesure
Section intitulée « Partie 3 : une comparaison équitable avec une seule mesure »D’abord, un piège. sweep rejoue l’échantillon avec chaque réglage d’une limite. Regardez le coût par tâche résolue, dans la dernière colonne :
python -m agentcost sweep --max-steps 30,40,45,50,51,55,60,75deepseek (deepseek-chat), 445 runs | no limit: US$13.5988, 176 solved, US$0.0773 per solved task step limit cost US$ saved solved wrong blocks timed out stopped per solved 30 9.0125 4.5863 161 15 42 of 85 0.0560 40 10.3158 3.2830 174 2 25 of 85 0.0593 45 10.7407 2.8581 175 1 20 of 85 0.0614 50 11.0477 2.5511 175 1 15 of 85 0.0631 51 11.1078 2.4910 176 0 13 of 85 0.0631 55 11.3085 2.2903 176 0 12 of 85 0.0643 60 11.4840 2.1148 176 0 10 of 85 0.0653 75 11.8631 1.7357 176 0 5 of 85 0.0674Le coût par tâche résolue baisse quand la limite se resserre. À 30 appels, il atteint son minimum : 0,0560 $ US. Mais ce réglage arrête 15 exécutions qui auraient réussi leurs tests. Il arrête aussi des exécutions échouées coûteuses. Le rapport semble donc meilleur, mais l’équipe perd du travail.
Ce rapport ignore la valeur d’une tâche résolue : une heure de travail d’ingénierie ou plus, contre environ 8 cents d’appels de modèle. Un seul blocage à tort coûte plus que les économies de toute limite sur cet échantillon. La mesure de Leo est donc : les dollars US qu’une limite économise sans blocage à tort. Chaque limite reçoit le réglage le plus strict qui n’arrête aucune exécution réussie de l’échantillon de conception. Nous comparons ensuite les économies de chaque réglage.
Testez les deux autres limites de la même façon. --max-idle arrête une exécution après ce nombre d’étapes inactives de suite :
python -m agentcost sweep --max-cost 0.04,0.06,0.08,0.1python -m agentcost sweep --max-idle 5,8,9,10,12cost limit US$ cost US$ saved solved wrong blocks timed out stopped per solved 0.04 9.3128 4.2860 170 6 26 of 85 0.0548 0.06 10.4507 3.1481 175 1 15 of 85 0.0597 0.08 11.0902 2.5086 175 1 9 of 85 0.0634 0.1 11.4110 2.1878 176 0 7 of 85 0.0648 idle limit cost US$ saved solved wrong blocks timed out stopped per solved 5 11.9181 1.6807 174 2 11 of 85 0.0685 8 12.0311 1.5678 174 2 8 of 85 0.0691 9 12.0901 1.5087 176 0 8 of 85 0.0687 10 12.1066 1.4922 176 0 8 of 85 0.0688 12 12.2200 1.3789 176 0 6 of 85 0.0694| Limite (vérifiée avant chaque appel) | Réglage le plus strict sans blocage à tort | Dollars US économisés sur 13,60 $ US | Exécutions dépassant le temps limite arrêtées |
|---|---|---|---|
| Limite d’étapes | 51 appels de modèle | 2,49 (18 %) | 13 sur 85 |
| Limite de coût | 0,10 $ US par exécution | 2,19 (16 %) | 7 sur 85 |
| Limite d’inactivité | 9 étapes inactives de suite | 1,51 (11 %) | 8 sur 85 |
Ce que cela nous apprend.
- La limite d’étapes économise le plus, et son réglage est facile à comprendre : la plus longue exécution réussie comptait 51 appels.
- La limite de coût est proche, mais son réglage est un prix : l’exécution réussie la plus coûteuse, au prix de ce modèle.
- La limite d’inactivité économise le moins, car une boucle doit commencer avant qu’elle agisse. Mais elle seule explique pourquoi une exécution gaspille de l’argent : une bonne alerte.
- Aucune limite n’arrête beaucoup des 85 exécutions qui dépassent le temps limite. La plupart étaient lentes, pas longues. Le temps limite du banc d’essai les arrête déjà.
Partie 4 : le réglage d’exploitation et le budget
Section intitulée « Partie 4 : le réglage d’exploitation et le budget »Un réglage à exactement 51 appels correspond à la longueur d’une seule exécution : la plus longue réussite d’un échantillon. La prochaine bonne exécution plus longue serait bloquée à tort. Leo choisit 60 appels par exécution, soit environ 18 % de plus.
python -m agentcost limits --max-steps 60deepseek (deepseek-chat): 445 runs | step limit 60 (checked before each model call)recorded outcome runs stopped cost US$ of US$solved 176 0 2.4986 2.4986failed 183 6 5.5454 5.8051timed_out 85 10 3.4026 5.2577error 1 0 0.0374 0.0374cost US$11.4840 (no limit: US$13.5988, saved US$2.1148) | solved 176 of 176 | solved runs stopped (wrong blocks): 0cost per solved task: US$0.0653 (no limit: US$0.0773)Cette marge réduit les économies de 0,38 $ US : 2,11 $ US plutôt que 2,49 $ US. L’exécution de 307 appels s’arrête maintenant après 60 appels, avant le début de sa boucle.
Un budget par tâche résolue
Section intitulée « Un budget par tâche résolue »Une limite d’étapes arrête une exécution. Elle ne dit pas à Hana quand l’agent dans son ensemble devient plus coûteux après un nouveau type de tâche, modèle ou requête. C’est le rôle de l’alerte budgétaire de Budgets, alertes et l’exécution coûteuse. Sa fenêtre est ici de 89 exécutions terminées, soit environ une exécution de chaque tâche. Essayez d’abord un budget de 0,09 $ US par tâche résolue sur les exécutions enregistrées, sans limite :
python -m agentcost budget --budget 0.09Budget: US$0.09 per solved task over the last 89 finished runs (from 20 runs on)Cost per solved task of the windows: lowest US$0.0469, median US$0.0762, highest US$0.1019Over budget after finished run 206 (chess-best-move__XimTT7i): US$0.0905 per solved task (33 solved, US$2.9849)The 5 runs that cost most in that window (40% of its cost):run outcome steps cost US$ idle streakfix-ocaml-gc__PB7o5ME timed_out 307 0.8696 173feal-linear-cryptanalysis__e9Scv8w failed 43 0.0871 2path-tracing-reverse__vLssimd failed 45 0.0849 1schemelike-metacircular-eval__H62ET7V failed 41 0.0760 1train-fasttext__MvTjpMW timed_out 70 0.0725 1Windows over the budget: 40 of 426L’alerte nomme ses exécutions, et la première est la boucle : 307 appels et une série de 173 étapes inactives. Maintenant, utilisez le même budget avec la limite d’étapes en place :
python -m agentcost budget --budget 0.09 --max-steps 60Budget: US$0.09 per solved task over the last 89 finished runs (from 20 runs on, with step limit 60)Cost per solved task of the windows: lowest US$0.0469, median US$0.0626, highest US$0.0815Never over budget.Ce que cela nous apprend. Avec la limite d’étapes, la fenêtre la plus coûteuse revient à 0,0815 $ US par tâche résolue. Un budget de 0,09 $ US se situe environ 10 % au-dessus. Il reste silencieux pendant le travail normal. Il se déclenche quand une période coûte plus que toute fenêtre de cet échantillon. La limite arrête une exécution; le budget surveille l’agent.
Écrivez le choix dans recommendation.json. Trouvez l’entrée default (par défaut), les réglages de l’équipe pour tout modèle, et inscrivez vos valeurs :
"default": {"max_steps": 60, "budget_per_solved_usd": 0.09},Le fichier définit aussi "idle_alert_streak": 10. Cela envoie un message au responsable de l’agent quand une exécution fait 10 appels inactifs de suite. C’est une alerte, pas un arrêt. Sur l’échantillon de conception, elle signale 8 exécutions, qui ont toutes dépassé le temps limite.
Description textuelle du diagramme
Avant chaque appel de modèle, la limite d’étapes du modèle décide : 60 appels pour DeepSeek-V3.2, 75 pour Claude Opus 4.6. Quand l’exécution l’atteint, elle s’arrête et sa tâche est confiée à une personne. Sinon, le fournisseur répond et l’argent est dépensé. Le span enregistre les jetons, le coût et la version de la table des prix. Deux alertes surveillent ensuite. L’alerte d’inactivité se déclenche après 10 appels inactifs de suite. Le budget par tâche résolue, par modèle et sur 89 exécutions terminées, nomme ses exécutions les plus coûteuses. Une personne décide quoi changer.
Partie 5 : de nouvelles données d’entrée, de bout en bout
Section intitulée « Partie 5 : de nouvelles données d’entrée, de bout en bout »Plus tard, un fournisseur propose à Hana un modèle plus puissant : Claude Opus 4.6. Son prix par jeton d’entrée est environ 18 fois plus élevé. Leo refait toute la vérification sur les exécutions du même agent avec ce modèle, en utilisant ses réglages actuels. La commande report effectue les étapes de cette page en une seule exécution.
-
Lancez la vérification avec l’entrée par défaut seulement :
Fenêtre de terminal python -m agentcost report --data opus== opus: 445 runs of claude-opus-4-6 | settings: recommendation.json, the default entry (no entry for claude-opus-4-6)outcomes: solved 280, failed 92, timed_out 73 | cost US$281.16, US$0.6318 a run, US$1.0041 per solved tasksolved runs: model calls median 9, longest 63 | cost median US$0.2901, highest US$5.1244== the step limit: step limit 60cost US$269.87 (saved US$11.29, 4%) | timed-out runs stopped 9 of 73 | solved runs stopped (wrong blocks): 1cost per solved task: US$0.9673 (no limit: US$1.0041)== the idle alert: 10 idle steps in a row (an alert to a person, not a stop)runs it flags: 13 (solved 1, failed 1, timed_out 11)== the budgetBudget: US$0.09 per solved task over the last 89 finished runs (from 20 runs on, with step limit 60)Cost per solved task of the windows: lowest US$0.3179, median US$0.9237, highest US$1.2267Over budget after finished run 20 (overfull-hbox__RhLQrUa): US$0.3290 per solved task (16 solved, US$5.2640)…Windows over the budget: 426 of 426 -
Vérifiez la table des prix pour ce modèle :
python -m agentcost check --data opus.recorded cost on 6,663 calls: US$291.93; our price table: US$281.16 (1,410 calls equal to the recorded cost, -3.7% in all)price table 2026-10-23: Claude Opus 4.6 US$5 in, US$0.5 cached in, US$25 out per 1M tokensCe sont les prix courants de la page des tarifs d’Anthropic, vérifiés à la date de version de la table. Ce sont des hypothèses associées à cette date, comme tous les prix de ce cours.
-
Rejouez les trois limites sur les nouvelles exécutions :
Fenêtre de terminal python -m agentcost sweep --data opus --max-steps 51,55,60,63,64,75python -m agentcost sweep --data opus --max-cost 0.1,1,3,6python -m agentcost sweep --data opus --max-idle 9,10,12step limit cost US$ saved solved wrong blocks timed out stopped per solved51 263.3778 17.7833 278 2 13 of 73 0.947455 266.4335 14.7277 279 1 12 of 73 0.955060 269.8707 11.2904 279 1 9 of 73 0.967363 271.5874 9.5738 280 0 6 of 73 0.970064 271.9707 9.1905 280 0 5 of 73 0.971375 275.1832 5.9780 280 0 3 of 73 0.9828cost limit US$ cost US$ saved solved wrong blocks timed out stopped per solved0.1 55.5477 225.6135 29 251 69 of 73 1.91541 208.1909 72.9703 261 19 33 of 73 0.79773 264.8661 16.2951 275 5 9 of 73 0.96316 280.8568 0.3044 280 0 1 of 73 1.0031idle limit cost US$ saved solved wrong blocks timed out stopped per solved9 272.3962 8.7650 278 2 12 of 73 0.979810 274.1643 6.9969 279 1 10 of 73 0.982712 277.6973 3.4639 280 0 7 of 73 0.9918
- DeepSeek-V3.2 (l'échantillon de conception)
- Claude Opus 4.6 (les nouvelles données d'entrée)
Description textuelle du graphique
Deux courbes d’exécutions réussies arrêtées, pour des limites d’étapes de 10 à 100, par pas de 5. DeepSeek-V3.2 : 113 à 10, 45 à 20, 15 à 30, 2 à 40, 1 à 50, et aucune à partir de 55. Claude Opus 4.6 : 120 à 10, 37 à 20, 16 à 30, 4 à 40, 2 à 50, 1 à 55 et à 60, et aucune à partir de 65.
Ce que cela nous apprend.
- La limite d’étapes était presque transférable. La plus longue exécution réussie d’Opus comptait 63 appels. La limite de 60 a donc arrêté une bonne exécution. Une limite de 75 n’en arrête aucune.
- La limite de coût n’était pas du tout transférable. 0,10 $ US était sûr sur DeepSeek; sur Opus, cette limite arrête 251 des 280 exécutions réussies. Une limite monétaire est un prix. Elle appartient donc à un modèle.
- La limite d’inactivité n’était pas transférable non plus. Les exécutions réussies d’Opus comptaient jusqu’à 11 étapes inactives de suite. Ses plus longues séries sont des attentes légitimes : 32 commandes vides pendant une compilation (
python -m agentcost idle --data opus). La règle d’inactivité reste une alerte. - Le budget a été dépassé immédiatement : chaque fenêtre dépassait 0,09 $ US. Les fenêtres d’Opus coûtaient de 0,32 $ US à 1,23 $ US par tâche résolue.
- Notre table des prix est 3,7 % sous le coût enregistré. Les enregistrements comptent les lectures du cache, mais pas les écritures. Celles-ci coûtent 1,25 fois le prix d’entrée. Pour Opus, considérez les chiffres du projet comme un minimum.
Leo donne au modèle sa propre entrée dans recommendation.json. Le budget est environ 10 % au-dessus de la fenêtre la plus coûteuse d’Opus avec la nouvelle limite (1,2658 $ US) :
"models": { "claude-opus-4-6": {"max_steps": 75, "budget_per_solved_usd": 1.40}}Relancez python -m agentcost report --data opus :
== the step limit: step limit 75cost US$275.18 (saved US$5.98, 2%) | timed-out runs stopped 3 of 73 | solved runs stopped (wrong blocks): 0cost per solved task: US$0.9828 (no limit: US$1.0041)…Budget: US$1.4 per solved task over the last 89 finished runs (from 20 runs on, with step limit 75)Cost per solved task of the windows: lowest US$0.3179, median US$0.9373, highest US$1.2658Never over budget.Le modèle plus puissant en vaut-il la peine? Il a résolu 280 tâches contre 176, et coûté 281,16 $ US contre 13,60 $ US. Chacune des 104 tâches résolues supplémentaires a coûté (281,16 − 13,60) ÷ 104 = 2,57 $ US. À ces prix, le changement est rentable si une heure de travail d’ingénierie coûte plus que cela. C’est la décision de Hana. Elle peut maintenant la prendre avec des chiffres.
La recommandation
Section intitulée « La recommandation »Leo l’écrit pour Hana, dans ses mots :
- Arrêter une exécution après 60 appels de modèle avec DeepSeek-V3.2, et après 75 avec Claude Opus 4.6. Sur les exécutions enregistrées, la limite de 60 a économisé 16 % sans arrêter de tâche résolue.
- Définir un budget par tâche résolue pour chaque modèle, sur les 89 dernières exécutions terminées : 0,09 $ US pour DeepSeek-V3.2, 1,40 $ US pour Claude Opus 4.6. Quand l’alerte se déclenche, commencer par les exécutions qu’elle liste.
- Déclencher une alerte après 10 appels inactifs de suite; ne pas les arrêter. Sur Opus, certains correspondaient à des attentes légitimes.
- Conserver les versions de la table des prix et la comparer chaque mois à la facture du fournisseur. Pour Opus, notre table omet les écritures du cache : elle est trop basse de 3,7 %.
- Revérifier chaque réglage à chaque changement de modèle, et après nos premières semaines d’exécutions. Ces chiffres viennent d’un banc d’essai public.
Les limites ne font pas réussir une exécution échouée. Les 183 exécutions échouées ont coûté 5,81 $ US. La limite d’étapes n’en a arrêté que 6. Les échecs sont une question de qualité : évaluez l’agent sur vos propres tâches, comme dans Évaluer et tester les systèmes d’IA.
Constats et limites
Section intitulée « Constats et limites »- La longueur détermine la facture. Chaque appel renvoie l’historique. Le coût d’une exécution augmente donc plus vite que son nombre d’appels.
- Le cache est le principal levier de coût. Un horodatage au début de la requête empêcherait son utilisation et multiplierait la facture sans autre signe.
- Le coût par tâche résolue exige un deuxième chiffre. À lui seul, il favorisait une limite qui arrêtait 15 bonnes exécutions. Comptez les blocages à tort à côté.
- Un réglage appartient à un agent et à un modèle. Les limites de Larkfield ont arrêté 146 des 176 bonnes exécutions. La limite monétaire de DeepSeek a arrêté 251 des 280 exécutions réussies d’Opus.
- Un banc d’essai n’est pas votre liste de tâches à faire. Il s’agit de 89 tâches difficiles dans des conteneurs neufs, exécutées en parallèle. L’ordre de la fenêtre est celui du banc d’essai, pas celui d’une journée de travail.
- Les enregistrements ont des lacunes. Une étape inactive est une estimation fondée sur des empreintes. Les temps du modèle et du terminal ne sont pas séparés. Les écritures du cache ne sont pas comptées.
Utilisation responsable
Section intitulée « Utilisation responsable »- Décrivez les données honnêtement. Ce sont des exécutions d’un banc d’essai public, faites par l’agent d’une autre équipe, chiffrées avec notre table. C’est un point de départ, pas une mesure de votre agent.
- Un arrêt doit assurer un bon passage de relais. Une personne a besoin de la tâche, de la trace de l’exécution et de la raison de l’arrêt. Testez ce parcours avant la première nuit.
- Gardez le code et les secrets hors des enregistrements. Une empreinte de chaque commande suffit à trouver les répétitions. Les commandes et sorties de votre agent peuvent contenir du code ou des clés. Gardez-les hors des spans, comme dans Ce qu’il faut enregistrer, et ce qu’il ne faut pas.
- Citez la source. Conservez le texte de la licence Apache-2.0 et l’avis de nos modifications avec votre copie, comme dans la fiche du jeu de données.
En faire un projet de portfolio
Section intitulée « En faire un projet de portfolio »Ce projet montre ce qu’un partenaire des plateformes ou des finances recherche. Un enregistrement permet de vérifier les coûts. Les preuves déterminent les limites. La page compte les deux erreurs, et de nouvelles entrées testent le choix.
Quoi mettre dans le dépôt :
coding-agent-cost/ 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/runs/ the fixed sample and the Apache-2.0 licence text prices.json the versioned price table recommendation.json your settings, per model agentcost/ data, prices, loops, limits, budget, the OpenTelemetry export tests/ 16 tests LICENSE MIT, for your code- Créez un dépôt Git à partir du dossier de votre projet, puis poussez-le vers GitHub.
.gitignoreexclutwork/etresults/. - Remplissez le tableau des résultats du README avec vos propres sorties : la référence de base, les trois limites, votre réglage et la vérification avec de nouvelles entrées.
- Précisez dans le README quels nombres viennent des enregistrements, lesquels viennent de votre table de prix et lesquels sont des hypothèses.
En deux phrases, pour une entrevue :
« J’ai mesuré 445 exécutions enregistrées d’un agent de programmation ouvert, par tâche, appel et résultat, puis choisi ses limites selon les preuves. Une limite de 60 appels a économisé 16 % sans perdre de tâche résolue; un autre modèle nécessitait 75 appels. »
Pour aller plus loin : calculez le coût des exécutions Opus en supposant des écritures en cache. Par exemple, facturez chaque nouveau jeton d’entrée à 1,25 fois le prix. À quel point vous rapprochez-vous du montant enregistré de 291,93 $ US? Ou attribuez une valeur à une tâche résolue, comme une heure de travail d’ingénieur. Choisissez ensuite la limite d’étapes qui maximise la valeur moins le coût. Ou exportez les exécutions avec --max-steps 60, puis comparez obs cost --by outcome avant et après la limite.
Vérification des connaissances
Section intitulée « Vérification des connaissances »Vérifiez votre compréhension
Dans l'échantillon de conception, une exécution réussie coûte en moyenne 0,0142 $ US, mais une tâche résolue coûte 0,0773 $ US. Expliquez la différence et dites quel nombre Hana devrait donner aux finances.
Afficher la réponse
Le coût d’une exécution réussie compte seulement les exécutions qui ont réussi. Le coût par tâche résolue divise toutes les dépenses, soit 13,60 $ US, par les 176 tâches résolues. Les exécutions échouées et celles ayant dépassé le délai font donc partie du prix de chaque réussite. Les finances devraient recevoir le coût par tâche résolue, avec la version de la table de prix. L’équipe paie pour chaque exécution. Avec la limite de 60 étapes, ce coût tombe à 0,0653 $ US.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
Une limite de 30 appels donnait le coût par tâche résolue le plus bas, soit 0,0560 $ US. Pourquoi Leo ne l'a-t-il pas choisie, et quelle mesure a-t-il utilisée à la place?
Afficher la réponse
À 30 appels, la limite a arrêté 15 exécutions qui auraient réussi leurs tests, ainsi que plusieurs exécutions échouées coûteuses. Le ratio a baissé, mais l’équipe a perdu du travail valant bien plus que les cents économisés. Leo a donc mesuré les dollars US que chaque limite économise sans blocage erroné. La limite d’étapes a gagné : 51 appels et 2,49 $ US économisés. Il a ajouté une marge pour atteindre 60 appels.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Vérifiez votre compréhension
L'équipe passe à Claude Opus 4.6 et conserve les réglages qui fonctionnaient sur DeepSeek-V3.2. Que montrent les nouvelles entrées pour la limite d'étapes, la limite de coût et le budget?
Afficher la réponse
La limite de 60 étapes a arrêté une exécution réussie. La plus longue exécution réussie d’Opus comptait 63 appels, et une limite de 75 n’en arrête aucune. Une limite de coût de 0,10 $ US arrêterait 251 des 280 exécutions réussies, car une limite monétaire dépend du prix. Le budget de 0,09 $ US a été dépassé dans chaque fenêtre. Chaque modèle nécessite sa propre entrée : ici, 75 appels et 1,40 $ US par tâche résolue.
Votre réponse contient-elle les points principaux de la nôtre ?
Connectez-vous et inscrivez-vous au cours pour enregistrer vos réponses. Chaque vérification compte pour le certificat.
Récapitulatif
- Chaque appel d’un agent de programmation envoie tout son historique. Sa longueur détermine donc le coût. Le cache a divisé la facture de cet agent par 6,3.
- Une tâche résolue coûtait 0,0773 $ US; seulement 18 % de l’argent a servi à résoudre des tâches. Les exécutions de plus de 40 appels représentaient 12 % des exécutions et 44 % du coût.
- Les étapes sans action ont révélé les boucles : jusqu’à 173 appels consécutifs sans commande.
- Le coût par tâche résolue, à lui seul, favorise les limites qui arrêtent du bon travail. Mesurez l’argent économisé sans blocage erroné, puis ajoutez une marge.
- Avec un autre modèle, la limite d’étapes devait atteindre 75. La limite monétaire et le budget ont complètement changé.
Vous pouvez maintenant transformer les exécutions enregistrées d’une autre équipe en rapport de coûts et en limites que vous pouvez justifier. La dernière étude de cas pose une autre question sur les enregistrements. Quand une entreprise a dû justifier les actions de son assistant d’IA, ses enregistrements auraient-ils pu répondre?
Leçon suivante : Les enregistrements auraient-ils pu répondre ?