Aller au contenu
English

Utilisation et coût par agent

  • Leçon 17
  • 40 min
  • Module 6 : Utilisation, preuves et IA fantôme

Où nous en sommes

Dans le module 5, nous avons placé la passerelle d'outils, la politique d'approbation et les arrêts d'urgence entre les agents et leurs actions. Maintenant, chaque appel de modèle et chaque appel d'outil laisse un enregistrement qui nomme l'agent. Mais personne ne lit encore ces enregistrements. Personne ne peut donc dire qui a dépensé quoi, ni combien une tâche a coûté. Dans cette leçon, nous transformons les enregistrements en rapports, comme un bureau examine son compte de taxi.

Ce que vous saurez faire

Transformez les enregistrements de la passerelle en rapports d’utilisation et de coût par agent, par équipe et par capacité. Joignez-les ensuite à la trace de l’application à l’aide de l’identifiant d’exécution. Vous obtenez le coût d’une tâche et celui d’une tâche résolue par l’agent.

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

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Votre projet ~/projects/ai-estate du module 5, identique à l’instantané end-of-m05, avec son environnement virtuel actif. python -m pytest -q affiche 190 passed, 1 deselected (190 tests réussis, 1 exclu). Si votre projet ne fonctionne plus, copiez l’instantané end-of-m05 comme l’explique le README des exercices.
  • Cette leçon n’ajoute aucun fichier. Elle lit le stockage d’utilisation, state/usage.db, avec la commande sqlite3 intégrée à Python. Cette commande nécessite Python 3.12 ou une version plus récente.

Testé sur macOS (Apple silicon) avec Python 3.12.13. Les commandes Windows (PowerShell) et Linux sont fournies, mais elles n’ont pas été exécutées dans le cours. Chaque réponse est rejouée à partir d’un enregistrement d’un cours précédent. Chaque coût utilise les prix du cours. Les prix changent : consultez la page des prix actuels du fournisseur pour un travail réel.

Imaginez un bureau qui possède un compte chez une compagnie de taxi. Chaque trajet donne un reçu. Le reçu indique la personne transportée, son service, le type de voiture et le prix. À la fin du mois, le responsable du bureau additionne les reçus de différentes façons. Par personne : qui prend le taxi le plus souvent? Par service : les ventes respectent-elles leur budget de déplacement? Par type de voiture : les gens prennent-ils de grandes voitures quand une petite suffirait?

Une autre question est plus difficile : combien a coûté l’acquisition du nouveau client? Les trajets liés à ce travail menaient au bureau du client, à la gare et à un hôtel. Ils ont eu lieu à différents jours, avec différentes personnes. Le responsable peut les additionner seulement si chaque reçu porte le même code de projet. Même alors, les reçus ne disent pas si le client a signé. Cette information se trouve dans le journal du projet.

Le problème : des enregistrements que personne ne lit

Section intitulée « Le problème : des enregistrements que personne ne lit »

Les passerelles de Larkfield écrivent maintenant une ligne pour chaque appel de modèle et chaque appel d’outil. En septembre, le mois rejoué, la passerelle de modèles a répondu à 40 754 appels des agents enregistrés. Personne ne peut lire 40 754 lignes. Kwame reçoit donc encore des questions auxquelles les enregistrements pourraient répondre, mais ne répondent pas encore :

  • Omar demande : « Combien strong-reasoning nous coûte-t-il par mois? » Il veut lui associer un modèle moins cher. Il lui faut donc d’abord ce chiffre.
  • Amira demande : « L’équipe de service respecte-t-elle son budget? » Son équipe possède trois agents.
  • Grace demande : « Combien cela coûte-t-il quand le flux de travail résout un billet de soutien? » Elle veut comparer ce coût au temps d’une personne.

Avant la passerelle, la facture du fournisseur était le seul enregistrement. Elle montre des clés, pas des applications, comme vous l’avez vu dans Découvrir le parc d’IA de Larkfield. Maintenant, les enregistrements nomment l’agent. Il suffit de les regrouper.

Un rapport d’utilisation additionne les lignes de la passerelle par groupe : par agent, par équipe, par capacité ou par modèle. Chaque groupe occupe une ligne, avec le nombre d’appels, leur résultat, les jetons et le coût. C’est le travail du responsable du bureau avec ses reçus.

Quand la plateforme montre à chaque équipe le coût de ses agents, on parle de ventilation des coûts (showback). Quand l’entreprise impute aussi ce coût au budget de chaque équipe, on parle de refacturation (chargeback). Larkfield pratique la ventilation des coûts : chaque équipe a un budget mensuel dans config/teams.yaml, que les rapports affichent.

Le diagramme montre une ligne réelle de l’exécution de cette leçon et les quatre groupes dans lesquels elle compte.

Un flux de gauche à droite. Un appel de modèle : support-workflow demande strong-reasoning. La passerelle écrit une ligne : agent support-workflow, équipe service, capacité strong-reasoning, modèle chat-strong (gpt-6.1-sol-2026-09-29), 2 182 jetons d'entrée et 55 de sortie, coût de 0,004914 $ US, identifiant d'exécution T-90103-…-1. La ligne compte dans quatre groupes : par agent, support-workflow, 5 appels, 0,0294 $ US; par équipe, service, 45 appels, 0,0364 $ US; par capacité, strong-reasoning, 10 appels, 0,0511 $ US; par modèle, chat-strong, 10 appels, 0,0511 $ US.
Un appel, une ligne, quatre rapports. La même ligne s'ajoute à celle de l'agent, de l'équipe, de la capacité et du modèle.
Description textuelle du diagramme

Un appel de modèle : le flux de soutien demande strong-reasoning. La passerelle écrit une ligne. Elle nomme l’agent, support-workflow, et son équipe, service. Elle nomme la capacité, strong-reasoning, et le modèle qui a répondu, chat-strong, version gpt-6.1-sol-2026-09-29. Elle contient les jetons, 2 182 en entrée et 55 en sortie, le coût, 0,004914 $ US, et l’identifiant d’exécution. La même ligne compte dans quatre rapports. Par agent, support-workflow compte 5 appels pour 0,0294 $ US. Par équipe, service compte 45 appels pour 0,0364 $ US. Par capacité, strong-reasoning compte 10 appels pour 0,0511 $ US. Par modèle, chat-strong compte les mêmes 10 appels.

Vous créez un nouveau parc, envoyez un peu de trafic depuis chaque application, puis lisez les rapports. Les chiffres sont petits, ce qui vous permet de vérifier chacun à la main.

  1. Dans ~/projects/ai-estate, arrêtez les services et supprimez l’ancien état :

    Fenêtre de terminal
    python -m estate down
    python -m estate reset

    reset (réinitialiser) supprime state/ : le registre, les clés, les enregistrements d’utilisation et la base de données d’exercice. Vous partez sans enregistrements. Vos rapports montrent donc seulement le trafic de cette leçon.

  2. Enregistrez chaque application, examinez les trois à risque élevé, délivrez les identifiants et démarrez les services. Ce sont les étapes du README de l’instantané :

    Fenêtre de terminal
    python -m estate init
    for f in registrations/*.yaml; do python -m estate register "$f"; done
    for a in support-workflow support-mcp orders-mcp; do python -m estate review "$a" --next 2026-12-01; done
    for a in ticket-triage support-workflow doc-assistant release-judge helpdesk-assistant; do python -m estate credentials issue "$a"; done
    python -m estate up

    Les dernières lignes (vos numéros de processus seront différents) :

    front up (process 82523) http://127.0.0.1:8322/front
    toolgate up (process 82528) http://127.0.0.1:8326
  3. Envoyez des requêtes réelles enregistrées depuis trois applications, par la passerelle :

    Fenêtre de terminal
    python -m apps.replay ticket-triage --units 20 --via gateway
    python -m apps.replay doc-assistant --units 5 --via gateway
    python -m apps.replay release-judge --units 5 --via gateway
    ticket-triage: 40 requests through the gateway | status {200: 40}
    answered by: chat-small (gpt-6-luna-2026-09-22) x20, embed-small (text-embedding-3-small) x20
    tokens: 39,575 in, 6,410 out | cost: US$0.0070
    doc-assistant: 5 requests through the gateway | status {200: 5}
    answered by: chat-small (gpt-6-luna-2026-09-22) x5
    tokens: 4,509 in, 875 out | cost: US$0.0009
    release-judge: 5 requests through the gateway | status {200: 5}
    answered by: chat-strong (gpt-6.1-sol-2026-09-29) x5
    tokens: 7,690 in, 632 out | cost: US$0.0217
  4. Exécutez trois tâches du flux de soutien par les deux passerelles. Sam approuve les deux premières :

    Fenêtre de terminal
    RESOLVER_PROVIDER=gateway RESOLVER_TOOLS=gateway python -m resolver run T-90103 --variant agent_structured --model strong-reasoning
    RESOLVER_PROVIDER=gateway RESOLVER_TOOLS=gateway python -m resolver approve T-90103-agent_structured-strong-reasoning-1 --as agent --approver usr-sam
    RESOLVER_PROVIDER=gateway RESOLVER_TOOLS=gateway python -m resolver run T-90104 --variant agent_structured --model strong-reasoning
    RESOLVER_PROVIDER=gateway RESOLVER_TOOLS=gateway python -m resolver approve T-90104-agent_structured-strong-reasoning-1 --as agent --approver usr-sam
    RESOLVER_PROVIDER=gateway RESOLVER_TOOLS=gateway python -m resolver run T-90301 --variant agent_structured --model strong-reasoning

    La première ligne de chaque run (exécution) indique le résultat, les appels et le coût vus par l’application :

    Outcome: resolve (rule W5) | 2 model call(s), 1 tool call(s) | 4647 tokens in, 266 out | US$0.01195
    Outcome: resolve (rule W2) | 2 model call(s), 1 tool call(s) | 4586 tokens in, 265 out | US$0.01182
    Outcome: hand_to_person (rule H1) | 1 model call(s), 0 tool call(s) | 2167 tokens in, 128 out | US$0.00561

    T-90103 concerne un pot à plantes fissuré : un nouvel envoi et une étiquette de retour gratuite. T-90104 concerne un arrosoir livré en retard : un remboursement des frais d’expédition de 9,95. T-90301 concerne une odeur de gaz près d’une valve de barbecue. C’est un cas de sécurité, donc l’agent le confie à une personne.

Avant d’additionner les lignes, examinez-en une. Le stockage d’utilisation est un seul fichier SQLite. Python 3.12 permet de l’interroger depuis la ligne de commande :

Fenêtre de terminal
python -m sqlite3 state/usage.db "select agent_id, team, capability, deployment, model_version, tokens_in, tokens_out, cost_usd, outcome, run_id from model_calls where agent_id = 'support-workflow' order by id limit 1"

Sur Windows, écrivez state\usage.db; le reste de la commande est identique.

('support-workflow', 'service', 'strong-reasoning', 'chat-strong', 'gpt-6.1-sol-2026-09-29', 2182, 55, 0.004914, 'ok', 'T-90103-agent_structured-strong-reasoning-1')

Chaque valeur répond à une question. Qui a appelé : support-workflow, de l’équipe service. Pour quoi : strong-reasoning. Qu’est-ce qui a répondu : chat-strong, version gpt-6.1-sol-2026-09-29. Quelle quantité : 2 182 jetons d’entrée et 55 de sortie. Les prix du cours pour chat-strong sont de 2 $ US par million de jetons d’entrée et de 10 $ US par million de jetons de sortie. Cela donne 0,004364 + 0,000550 = 0,004914 $ US. Comment l’appel s’est terminé : ok (réussi). Pour quelle tâche : l’identifiant d’exécution. La ligne ne contient ni requête ni texte de réponse : la passerelle n’en conserve aucun.

  1. Par agent, le choix par défaut :

    Fenêtre de terminal
    python -m estate usage
    agent calls ok refused failed tokens in tokens out US$
    ------------------------------------------------------------------------------------------------------
    support-workflow 5 5 0 0 11,400 659 0.0294
    release-judge 5 5 0 0 7,690 632 0.0217
    ticket-triage 40 40 0 0 39,575 6,410 0.0070
    doc-assistant 5 5 0 0 4,509 875 0.0009
    total 55 55 0 0 63,174 8,576 0.0590

    Vérifiez une ligne à la main : les 5 appels du flux de travail sont les 2 + 2 + 1 de ses trois tâches. Et 0,01195 $ US + 0,01182 + 0,00561 = 0,02938 $ US, affiché arrondi à 0.0294. Les lignes sont triées par coût. L’agent le plus cher apparaît donc en premier, même s’il a fait le moins d’appels.

  2. Par équipe :

    Fenêtre de terminal
    python -m estate usage --by team
    team calls ok refused failed tokens in tokens out US$
    ------------------------------------------------------------------------------------------------------
    service 45 45 0 0 50,975 7,069 0.0364
    evaluation 5 5 0 0 7,690 632 0.0217
    data 5 5 0 0 4,509 875 0.0009
    total 55 55 0 0 63,174 8,576 0.0590

    L’équipe service est celle d’Amira : le triage (40 appels) et le flux de travail (5 appels). L’assistant du centre d’assistance lui appartient aussi, mais il n’a fait aucun appel de modèle aujourd’hui.

  3. Par capacité, la question d’Omar :

    Fenêtre de terminal
    python -m estate usage --by capability
    capability calls ok refused failed tokens in tokens out US$
    ------------------------------------------------------------------------------------------------------
    strong-reasoning 10 10 0 0 19,090 1,291 0.0511
    fast-small 25 25 0 0 42,638 7,285 0.0079
    embed 20 20 0 0 1,446 0 0.0000
    total 55 55 0 0 63,174 8,576 0.0590

    Dix appels strong-reasoning coûtent plus de six fois le coût des 25 appels fast-small. Deux consommateurs partagent strong-reasoning : le flux de travail (5 appels) et le juge des mises en production (5 appels).

  4. Par modèle :

    Fenêtre de terminal
    python -m estate usage --by model
    model calls ok refused failed tokens in tokens out US$
    ------------------------------------------------------------------------------------------------------
    chat-strong (gpt-6.1-sol-2026-09-29) 10 10 0 0 19,090 1,291 0.0511
    chat-small (gpt-6-luna-2026-09-22) 25 25 0 0 42,638 7,285 0.0079
    embed-small (text-embedding-3-small) 20 20 0 0 1,446 0 0.0000
    total 55 55 0 0 63,174 8,576 0.0590

    Aujourd’hui, chaque capacité est associée à un modèle, donc les deux rapports concordent. Après une nouvelle association ou un recours au modèle de secours, ils diffèrent. Le rapport par capacité indique ce que les applications ont demandé. Le rapport par modèle indique ce qui a réellement répondu.

Les mêmes rapports, pour le mois de septembre rejoué, répondent aux questions de Kwame. Le graphique compare les dépenses de chaque agent dans les enregistrements de la passerelle à son budget mensuel. Les budgets proviennent des formulaires d’enregistrement. Ce sont des hypothèses du cours.

Les enregistrements de la passerelle pour le mois rejoué, comparés au budget mensuel de chaque agent. Réponses rejouées, prix du cours, budgets supposés.
Description textuelle du graphique

Cinq barres, en pourcentage du budget mensuel de chaque agent. Le flux de soutien a utilisé 57 % de 25 $ US (14,28 $ US). Le triage des billets a utilisé 43 % de 15 $ US (6,48 $ US). Le juge des mises en production a utilisé 5 % de 8 $ US, et l’assistant documentaire, 4 % de 3 $ US. L’assistant du centre d’assistance n’a rien utilisé de ses 2 $ US.

La réponse à Amira est donc oui : l’équipe de service a dépensé 20,76 $ US sur ses 40 $ US dans les enregistrements de la passerelle. Et la réponse à Omar : strong-reasoning a coûté 14,70 $ US sur les 21,31 $ US de la passerelle en septembre. Cela représente 2 690 des 40 754 appels ayant reçu une réponse. C’est une petite part des appels et la majeure partie de l’argent. Voilà pourquoi il demande un modèle moins cher. C’est aussi pourquoi Modifier une association en toute sécurité lui a d’abord fait franchir une barrière.

Mais relisez la ligne du flux de travail, car un rapport peut induire en erreur. Le prochain graphique répartit ses dépenses de septembre selon leur destination.

Le mois rejoué : directement au fournisseur avant la migration du flux le 10 septembre, par la passerelle pour le travail normal, et dans la boucle incontrôlée du 22 septembre (une boucle construite sur une requête réelle enregistrée).
Description textuelle du graphique

Trois barres, en dollars US. Avant sa migration le 10 septembre, le flux de travail a dépensé US$4.44 directement auprès du fournisseur, avec la clé partagée de l’équipe de service. Par la passerelle, son travail normal a coûté US$10.19. La boucle incontrôlée du 22 septembre a coûté US$4.09 avant que le quota quotidien l’arrête.

Deux constats en découlent. D’abord, US$4.09 des 14,28 $ US du flux de travail provient d’un mauvais déploiement qui a tourné en boucle. C’est 29 % de son mois, en une heure. Un rapport de coût par agent montre qu’il s’est passé quelque chose. Il ne dit pas quoi. Vous examinez donc la journée et l’incident. Ensuite, les enregistrements de la passerelle commencent le jour de la migration de chaque application. En septembre, les applications ont aussi dépensé 7,36 $ US directement auprès du fournisseur avant leur migration. Cela représente 2,04 $ US pour le triage, 4,44 $ US pour le flux de travail, 0,83 $ US pour le juge avec la clé personnelle de Priya, et 0,05 $ US pour les documents. Seule la facture du fournisseur montre cet argent. Un rapport fondé uniquement sur les enregistrements de la passerelle ne dit rien des appels qui ne l’ont pas traversée.

Coût par tâche : joindre la trace de l’application

Section intitulée « Coût par tâche : joindre la trace de l’application »

La question de Grace porte sur une tâche, pas sur un appel. Une tâche du flux de travail fait plusieurs appels de modèles et plusieurs appels d’outils. Seule l’application sait comment elle s’est terminée. La passerelle voit chaque appel séparément.

La plateforme demande donc à chaque application d’envoyer un identifiant d’exécution à chaque appel, dans l’en-tête X-Run-Id, et un en-tête W3C traceparent. L’identifiant d’exécution est le code de projet sur les reçus de taxi. Le flux de travail envoie son identifiant d’exécution, par exemple T-90103-agent_structured-strong-reasoning-1. Il envoie aussi un traceparent dont la partie trace provient de l’identifiant d’exécution. L’application garde son propre enregistrement de l’exécution, sa trace : les étapes, les résultats des outils et le résultat final. Joindre les deux par l’identifiant d’exécution donne le coût de chaque tâche et son résultat.

  1. Additionnez les lignes de la passerelle par exécution du flux de travail :

    Fenêtre de terminal
    python -m sqlite3 state/usage.db "select run_id, count(*), sum(tokens_in), sum(tokens_out), round(sum(cost_usd), 5) from model_calls where agent_id = 'support-workflow' group by run_id"
    ('T-90103-agent_structured-strong-reasoning-1', 2, 4647, 266, 0.01195)
    ('T-90104-agent_structured-strong-reasoning-1', 2, 4586, 265, 0.01182)
    ('T-90301-agent_structured-strong-reasoning-1', 1, 2167, 128, 0.00561)

    Ce sont les mêmes coûts que chaque run a affichés. La passerelle et l’application concordent.

  2. Demandez à l’application comment chaque exécution s’est terminée :

    Fenêtre de terminal
    python -m resolver runs
    T-90103-agent_structured-strong-reasoning-1 done …
    T-90104-agent_structured-strong-reasoning-1 done …
    T-90301-agent_structured-strong-reasoning-1 handed_to_person …

    Chaque ligne se termine par l’heure de l’exécution (omise ici : …). Deux exécutions sont done (terminées) : la proposition de l’agent a été approuvée et réalisée. Une a été confiée à une personne.

  3. Examinez la trace d’une exécution, étape par étape :

    Fenêtre de terminal
    python -m resolver trace T-90103-agent_structured-strong-reasoning-1
    Run T-90103-agent_structured-strong-reasoning-1: agent_structured, strong-reasoning, ticket T-90103, status done
    2 model call(s), 4647 tokens in, 266 out, US$0.01195, 0.031 s waiting for the model
    1 plan ["Check the order’s delivery date, planter price and stock.", "Apply the damaged-item policy and propose the …
    1 model strong-reasoning: get_order({"order_id": "LK-640436"}) (2182 in, 55 out, 0.026 s)
    1 tool get_order({"order_id": "LK-640436"}) -> ok
    2 plan []
    2 model strong-reasoning: finish({"outcome": "resolve", "rule": "W5", "a…) (2465 in, 211 out, 0.005 s)
    2 proposal resolve (W5): reship_item LK-640436, create_return_label LK-640436
    2 stop finished
    2 approval approved by agent (agent)
    2 write reship_item op 221dccf204b80a63 -> done
    2 write create_return_label op 0f8c2e98df53719d -> done
    2 stop done

    La première étape de modèle, 2 182 jetons d’entrée et 55 de sortie, est la ligne que vous avez lue auparavant.

  4. Examinez les lignes de la passerelle d’outils pour les mêmes exécutions :

    Fenêtre de terminal
    python -m sqlite3 state/usage.db "select run_id, tool, kind, outcome, approver from tool_calls order by id"
    ('T-90103-agent_structured-strong-reasoning-1', 'get_order', 'read', 'ok', None)
    ('T-90103-agent_structured-strong-reasoning-1', 'reship_item', 'write', 'ok', 'usr-sam')
    ('T-90103-agent_structured-strong-reasoning-1', 'create_return_label', 'write', 'ok', 'usr-sam')
    ('T-90103-agent_structured-strong-reasoning-1', 'add_ticket_note', 'write', 'ok', None)
    ('T-90104-agent_structured-strong-reasoning-1', 'get_order', 'read', 'ok', None)
    ('T-90104-agent_structured-strong-reasoning-1', 'request_refund', 'write', 'ok', 'usr-sam')
    ('T-90104-agent_structured-strong-reasoning-1', 'add_ticket_note', 'write', 'ok', None)

    Chaque côté sait quelque chose que l’autre ignore. La trace de l’application indique approved by agent (approuvé par l’agent) : un rôle. La passerelle d’outils indique usr-sam : la personne dont elle a vérifié l’autorisation accordée. La trace contient le plan et le résultat; la passerelle contient le coût et la personne.

Joignez-les maintenant. Trois tâches coûtent 0,01195 $ US + 0,01182 + 0,00561 = 0,02938 $ US, soit 0,00979 $ US par tâche. Mais l’agent n’en a résolu que deux. La troisième a été confiée à une personne, qui doit encore faire le travail. Le coût par tâche résolue est donc de 0,02938 $ US / 2 = 0,01469 $ US. C’est le chiffre que Grace peut comparer au temps d’une personne. Il est 50 % plus élevé que le coût par tâche.

Deux groupes joints par l'identifiant d'exécution. Les enregistrements de la passerelle, le coût de chaque appel : T-90103, 2 appels, 0,01195 $ US; T-90104, 2 appels, 0,01182 $ US; T-90301, 1 appel, 0,00561 $ US. La trace de l'application, le résultat de chaque tâche : T-90103, terminée (nouvel envoi, étiquette); T-90104, terminée (remboursement de 9,95); T-90301, confiée à une personne. Après jointure par l'identifiant d'exécution : 3 tâches, 0,02938 $ US; 2 résolues par l'agent; 0,01469 $ US par tâche résolue.
Le coût par tâche résolue nécessite les deux enregistrements : la passerelle connaît le coût de chaque appel, et seule l'application connaît le résultat de chaque tâche.
Description textuelle du diagramme

D’un côté, les enregistrements de la passerelle indiquent le coût de chaque appel, regroupé par identifiant d’exécution. T-90103 a fait 2 appels pour 0,01195 $ US, T-90104, 2 appels pour 0,01182 $ US, et T-90301, 1 appel pour 0,00561 $ US. De l’autre côté, la trace de l’application indique le résultat de chaque tâche. T-90103 est terminée, avec un nouvel envoi et une étiquette. T-90104 est terminée, avec un remboursement de 9,95. T-90301 a été confiée à une personne. Après jointure par l’identifiant d’exécution, les trois tâches coûtent 0,02938 $ US. L’agent en a résolu deux, donc une tâche résolue a coûté 0,01469 $ US.

Dans cette leçon, la jointure repose sur trois lignes que vous additionnez à la main. À l’échelle de Larkfield, c’est un travail pour les traces. Chaque appel est un segment de trace (span) dans une trace par tâche. Un outil de traçage additionne les coûts par trace. Un cours ultérieur sur l’observabilité construit cette jointure avec de vraies traces. La partie de la passerelle est déjà faite : chaque ligne porte l’identifiant d’exécution et le traceparent.

Utilisez les rapports d’utilisation chaque mois et quand vous recevez une alerte de budget. Ils coûtent peu : les lignes existent déjà et un rapport demande une seule requête. Par agent et par équipe, ils indiquent qui dépense. Par capacité, ils indiquent où une nouvelle association réduirait les coûts. Par modèle, ils montrent lequel a vraiment répondu après les recours aux modèles de secours.

Ne les utilisez pas seuls pour juger un agent. Le coût par appel ne dit rien sur la qualité. L’appel le moins cher peut être celui qui confie chaque billet à une personne. Gardez trois limites en tête :

  • Seulement ce qui passe par la passerelle. Les registres excluent les appels directs à un fournisseur et les plongements (embeddings) de l’assistant documentaire sur un modèle local. La facture et les deux prochaines leçons couvrent le reste.
  • Seulement les prix du cours. Chaque ligne calcule le coût en multipliant les jetons par le prix dans config/models.yaml au moment de l’appel. La facture d’un vrai fournisseur peut différer : rabais, jetons en cache, changement de prix. Comparez les totaux à la facture chaque mois.
  • Le coût par tâche exige l’identifiant d’exécution partout. Sans identifiant d’exécution, une application peut figurer dans un rapport par agent, jamais par tâche. L’outil de rejeu du triage en envoie un par billet; le flux de travail en envoie un par exécution. Une nouvelle application doit l’envoyer dès le premier jour, sinon son historique ne pourra pas être joint plus tard.

Erreur courante

Le rapport est vide

Symptôme : vous demandez le mois et obtenez seulement une ligne de total, avec des zéros :

Fenêtre de terminal
python -m estate usage --month 2026-09
agent calls ok refused failed tokens in tokens out US$
------------------------------------------------------------------------------------------------------
total 0 0 0 0 0 0 0.0000

Cause : chaque ligne porte l’heure de l’appel selon l’horloge du parc, en UTC. Votre trafic appartient au mois de votre exécution, pas au mois de septembre rejoué. Le rapport de septembre est un fichier dans la prochaine leçon; ses lignes ne figurent pas dans votre registre d’utilisation.

Diagnostic : python -m estate usage sans --month montre toutes les lignes. Si vous voyez votre trafic, le mois est incorrect. Tard le soir, à l’ouest du fuseau UTC, vos lignes peuvent déjà appartenir au jour ou au mois suivant.

Solution : utilisez le mois de votre exécution, au format YYYY-MM (année-mois), ou omettez --month.

Changez d’unité : utilisez le service de triage, pas le flux de travail. L’outil de rejeu du triage envoie un identifiant d’exécution par billet; vous pouvez donc compter les billets.

  1. Prédisez : 20 billets, avec deux appels chacun, coûtent 0,0070 $ US dans le rejeu. Quel est le coût d’un billet?

  2. Vérifiez-le à partir des lignes de la passerelle :

    Fenêtre de terminal
    python -m sqlite3 state/usage.db "select count(distinct run_id), count(*), round(sum(cost_usd), 5) from model_calls where agent_id = 'ticket-triage'"
  3. Prédisez maintenant le mois. Le triage est passé par la passerelle dès le 8 septembre et traitait environ 822 billets par jour. C’est le nombre du cours MLOps et LLMOps : exploiter l’IA en production. Quel montant les registres de la passerelle devraient-ils indiquer pour le triage en septembre? Notez votre nombre, puis comparez-le aux 6,48 $ US du graphique.

Vérifiez votre réponse

Les réponses rejouées de l’exécution du cours :

(20, 40, 0.00705)

20 identifiants d’exécution, 40 appels, 0,00705 $ US. Un billet coûte 0,00705 $ US / 20 = 0,00035 $ US, soit un appel à chat-small et un plongement.

Du 8 au 30 septembre, il y a 23 jours, donc environ 822 × 23 = 18 906 billets. À 0,00035 $ US chacun, cela donne environ 6,62 $ US. Les registres de la passerelle indiquent 6,48 $ US pour 37 191 appels avec réponse : environ 18 600 billets. Votre estimation est proche parce que les 20 billets forment un échantillon représentatif des enregistrements. Le triage a changé de chemin pendant la journée du 8. Une partie du trafic de cette journée allait donc directement au fournisseur. Pendant la panne du 17 septembre, 35 appels de triage n’ont obtenu aucun fournisseur : ces billets ont été confiés à une personne.

Vérifiez votre compréhension

Le rapport par capacité et le rapport par modèle du même mois donnent des nombres différents pour strong-reasoning. Nommez deux raisons.

Afficher la réponse

Le rapport par capacité compte ce que les applications ont demandé. Le rapport par modèle compte le modèle qui a vraiment répondu. Ils diffèrent quand un appel utilise un modèle de secours, par exemple dans la deuxième région pendant une panne. Ils diffèrent aussi lorsqu’une nouvelle association change le modèle derrière la capacité pendant le mois. Ils diffèrent aussi lorsqu’une application utilisatrice fixe une version exacte du modèle. Ses appels comptent sous strong-reasoning, mais la version fixée répond.

Vérifiez votre compréhension

Le rapport du flux de travail indique 14,28 $ US en septembre. Amira dit : « Donc, une tâche coûte 14,28 $ US divisés par le nombre de tâches. » Quel est le problème, et que vous faut-il plutôt?

Afficher la réponse

Trois choses. De ce montant, 4,09 $ US viennent de la boucle emballée, pas des tâches. La passerelle ne connaît ni le nombre de tâches ni leur résultat : seule la trace de l’application le sait. Le montant exclut aussi les dépenses directes auprès du fournisseur avant le passage à la passerelle, le 10 septembre. Additionnez plutôt le coût par identifiant d’exécution à partir des lignes de la passerelle. Joignez-le à la trace de l’application avec le même identifiant d’exécution. Excluez les exécutions de la boucle emballée et divisez par les tâches que l’agent a résolues.

Vérifiez votre compréhension

Exercice pratique : exécutez une autre tâche du flux de travail en passant par les deux passerelles, par exemple T-90105. Trouvez son coût dans les lignes de la passerelle avec son identifiant d'exécution. Vérifiez qu'il correspond au coût affiché par l'application.

Afficher la réponse

Exécutez-la avec RESOLVER_PROVIDER=gateway RESOLVER_TOOLS=gateway python -m resolver run T-90105 --variant agent_structured --model strong-reasoning. Dans l’exécution du cours, la deuxième ligne était Outcome: reply_only (rule W6) | 2 model call(s), 1 tool call(s) | 4624 tokens in, 200 out | US$0.01125 (résultat : réponse seulement, règle W6; 2 appels de modèle, 1 appel d’outil; 4 624 jetons en entrée, 200 en sortie; 0,01125 $ US). Un sac de terreau ouvert ne peut pas être retourné, donc l’agent répond seulement. Exécutez ensuite python -m sqlite3 state/usage.db "select run_id, count(*), round(sum(cost_usd), 5) from model_calls where run_id = 'T-90105-agent_structured-strong-reasoning-1'". La commande a donné ('T-90105-agent_structured-strong-reasoning-1', 2, 0.01125) : les mêmes 2 appels et le même coût. Si aucune ligne ne s’affiche, l’identifiant d’exécution diffère : copiez-le depuis la première ligne de l’exécution.

Récapitulatif

  • La passerelle écrit une ligne par appel : agent, équipe, capacité, modèle, jetons, coût, résultat et identifiant d’exécution. Elle ne conserve aucune requête ni réponse.
  • python -m estate usage --by agent | team | capability | model regroupe les lignes. Le showback (présentation des coûts sans facturation interne) montre à chaque équipe son coût par rapport à son budget.
  • En septembre, strong-reasoning a coûté 14,70 $ US sur les 21,31 $ US de la passerelle, pour 2 690 des 40 754 appels. Une heure de boucle emballée représentait 4,09 $ US sur les 14,28 $ US du flux de travail.
  • Les registres de la passerelle excluent ce qui ne passe pas par elle. Avant la migration des applications, 7,36 $ US ont été dépensés directement auprès du fournisseur.
  • Le coût par tâche joint les lignes de la passerelle à la trace de l’application avec l’identifiant d’exécution. Trois tâches ont coûté 0,02938 $ US; par tâche résolue, 0,01469 $ US.

Votre projet reste inchangé : l’instantané end-of-m05, avec 190 tests. Son registre d’utilisation contient maintenant le trafic de cette leçon, que la prochaine leçon utilise. Vous pouvez maintenant dire qui a dépensé quoi et combien une tâche résolue a coûté. Mais le comité de gouvernance demande plus que les coûts : chaque agent est-il enregistré, lesquels présentent un risque élevé, qu’est-ce qui a mal fonctionné? Ensuite, nous répondons aux questions du comité à partir des preuves. Nous trouvons aussi la question à laquelle les preuves ne peuvent pas répondre.

Leçon suivante : Des preuves pour la gouvernance