Accueil / Articles

Les agents paient cher pour l’attente : comparaison des sondages, du blocage et des tâches

Un référentiel présentant trois manières dont un agent peut attendre la fin d’une opération cloud lente : la consultation périodique, le blocage et les tâches MCP, le coût en tokens de chacune, ainsi que des règles pour les concepteurs d’outils.

Éditeur : REACTAPP.TOP8 min de lecture1807 mots

Sources: Your Agent Doesn’t Know How to Wait

Presque toutes les API d’infrastructure cloud présentent cette même particularité. Une requête de création ne renvoie pas un resource terminé ; elle renvoie plutôt un reçu :

{
  "name": "operations/abc-123",
  "status": "RUNNING",
  "done": false
}

La base de données met plusieurs minutes à se mettre en route, et pendant ce temps, tout ce que possède l’appelant, c’est un identifiant de suivi. Il s’agit du modèle d’opération à long terme, ou LRO, qui relève à la fois de l’approvisionnement en infrastructure, de l’entraînement des modèles, des migrations de bases de données et du transcodage vidéo. Pour un utilisateur devant une console, c’est une tâche routinière : exécuter la commande, attendre, puis aller se chercher un café.

Pour un agent IA, cependant, cela représente un véritable défi en termes de conception. Les tests comparatifs des différentes façons de gérer cette attente ont montré une différence de coût de 5 fois, une pénalité de 11 fois en termes de tokens de sortie générés, ainsi que de graves goulots d’étranglement liés à la concurrence. La plupart des concepteurs d’outils ne se rendent pas compte qu’ils choisissent une approche précise lorsqu’ils écrivent les définitions de leurs outils. Cette comparaison a porté sur trois méthodes utilisées sur des charges de travail identiques avec le même modèle : la consultation en boucle par l’agent, l’attente bloquante sur le serveur, et la délégation de l’attente à une tâche gérée par un système de gestion.

Pourquoi attendre est coûteux

Un agent est un modèle de langage qui fonctionne en boucle. Il reçoit un objectif ainsi que des outils, raisonne, appelle un outil, examine le résultat et décide de ce qu’il doit faire. Chaque cycle représente une étape, et une étape n’est pas une requête HTTP isolée. À chaque étape, toute la conversation est réintégrée dans la fenêtre de contexte : le prompt du système, chaque définition d’outil, l’objectif ainsi que toutes les appels et réponses précédents. Le coût total de la tâche est donc approximativement le nombre d’étapes multiplié par la taille du contexte à chaque étape.

Imaginons maintenant qu’un agent vérifie l’état d’une opération. Il appelle la fonction get_operation et voit que l’opération est en cours (RUNNING) ; pour décider de la suite des actions, il doit effectuer une nouvelle inférence sur l’ensemble des données accumulées. Il appelle à nouveau la fonction, voit toujours que l’opération est en cours, et doit donc payer pour une autre inférence complète. Un modèle de type frontier, dont le prix est exprimé en dollars par million de tokens, est utilisé pour implémenter la fonction de sommeil.

Quatre termes reviennent fréquemment ci-dessous :

  • Étapes : nombre d’appels d’outils effectués par l’agent. Moins c’est mieux.
  • Tokens facturés : métrique de coût qui donne plus de poids au contexte en mémoire, à un dixième environ du prix d’une entrée fraîche. C’est le montant indiqué sur la facture cloud.
  • Éventail d’outils : tout ce que l’agent est autorisé à appeler, que ce soit via un serveur MCP ou en tapant des commandes CLI dans une invite de commande.
  • Tâches : travaux en arrière-plan confiés au framework ou au runtime MCP, ce qui permet à la thread principale de l’agent de rester libre.

Mode de fonctionnement du benchmark

Le test a utilisé Evalbench contre le même plan de contrôle de base de données cloud dans trois configurations :

  • MCP Toolbox, un serveur doté d’une configuration de base de données prédéfinie.
  • Un serveur MCP de base qui expose des outils de création, de lecture, de mise à jour et de suppression ainsi que l’état des opérations.
  • Une configuration CLI de secours (gcloud), sans outils MCP, où l’agent a recours à des commandes de shell.
  • Il y avait 12 tâches par niveau de difficulté, exécutées avec Claude Opus sur une version CLI fixe, avec un juge automatique chargé de noter les résultats. Parmi les tâches difficiles, deux ont duré longtemps : le clonage d’une instance et la mise en place d’une instance à haute disponibilité. Les trois configurations gèrent l’attente de trois manières différentes.

    Les trois modes d’attente

    Consultation en boucle

    Le serveur renvoie un ID d’opération et l’agent continue de poser des demandes au sein de sa boucle de raisonnement :

    create_instance()      → operations/abc-123
    get_operation(abc-123) → RUNNING
    get_operation(abc-123) → RUNNING
    ... ×10 ...
    get_operation(abc-123) → DONE
    

    Dix voyages complets à travers le contexte du modèle, juste pour découvrir qu’une copie est encore en cours de création.

    Blocage sur le serveur

    Le serveur met à disposition un outil qui maintient la connexion ouverte jusqu’à ce que l’opération atteigne un état final :

    create_instance()           → operations/abc-123
    wait_for_operation(abc-123) → DONE   (one call, eleven minutes later)
    

    C’est un premier pas. Le temps d’inactivité s’écoule sur un serveur facturé à une fraction infime de centime par heure, et non dans le contexte d’un modèle facturé en dollars par million de tokens. Le problème, c’est que le blocage est strictement séquentiel, et tant que l’appel reste ouvert, le thread de l’agent est figé.

    Tâches transférées au système de gestion

    Au lieu de bloquer l’agent ou de consommer des tokens pour des vérifications, l’agent transmet l’opération à un exécuteur de tâches en arrière-plan :

    Bash(cmd, run_in_background: true)  → task_id: task-8921
    ... agent configures network rules, audits schemas, writes migration scripts ...
    TaskOutput(task-8921, block: true)  → done
    

    Grâce à l’extension MCP Tasks, lancement d’une tâche et récupération de son résultat deviennent des événements distincts. L’agent lance le travail, reçoit un identifiant de tâche et passe à d’autres tâches utiles. Lorsqu’il a finalement besoin de la base de données, il vérifie cet identifiant ou attend un signal de finition. Ce schéma est le seul qui permet à un agent d’attendre plusieurs opérations en même temps ou de combiner une longue attente avec des calculs productifs.

    Le coût du test de clonage

    Lors de l’évaluation du clonage (cloner une instance, attendre qu’elle soit prête, vérifier son état), l’opération sous-jacente prend environ 13 minutes en temps réel dans chaque environnement. Les différences en termes de temps réel étaient faibles, mais les coûts en tokens variaient fortement :

    • MCP Toolbox, avec son mécanisme d’attente bloquante, a obtenu les meilleurs résultats sur tous les critères : 4 étapes, 211 854 tokens facturés, 765 secondes.
    • Le serveur MCP de base, effectuant dix vérifications, a nécessité le plus de temps, soit 864 secondes sur 23 étapes.
    • La CLI de secours présentait la charge la plus élevée : 328 316 tokens facturés et 14 108 tokens de sortie sur 19 étapes.

    La seule attente bloquante a réduit le nombre d’étapes de 80 %, les tokens facturés de 26 % par rapport à la méthode de sondage basique, et les coûts de 35 % par rapport à la CLI de secours. De plus, elle a terminé en premier, car les agents de sondage se réveillaient constamment pour effectuer des passes de raisonnement supplémentaires.

    Le chiffre le plus frappant concerne les tokens de sortie, qui étaient 11 fois plus élevés avec la CLI. En l’absence d’outils MCP, l’agent a dû écrire son propre script de tentative en bash :

    while true; do
      st=$(cloud-cli operations list --project=production-db \
           --instance=staging-replica --format='value(status)' | head -1)
      [ "$st" = "DONE" ] && break
      sleep 20
    done
    

    Il a écrit ce boucle trois fois sous des formes légèrement différentes, car chaque tentative échouait à effectuer un suivi propre. Finalement, il a abandonné et a défini un minuteur de réveil cinq minutes avant l’échéance. Un modèle autonome a consacré 14 000 tokens de sortie à réinventer wait_for_operation à partir de zéro, et l’a fait de manière médiocre. Un agent auquel on refuse la possibilité d’attendre en créera une à un coût élevé, et le résultat sera pire que l’outil qui n’a pas été livré.

    Guidelines pour les concepteurs d’API et d’outils

    Concevoir pour des agents signifie repenser les conventions REST et gRPC en fonction d’une contrainte qu’ils n’ont jamais rencontrée : chaque octet exposé est relu à chaque étape. Chaque pratique présentée ci-dessous repose sur des mesures concrètes.

    Proposer un modèle d’attente en plusieurs niveaux

    Différentes situations exigent des temps d’attente différents, il convient donc de proposer les trois niveaux afin que l’agent puisse choisir :

    create_instance()                       → { "operation": "operations/abc-123", "done": false }
    get_operation(id)                       → Tier 1: inspect status, resume after interruption
    wait_for_operation(id, timeout_seconds) → Tier 2: the 90% single-instance case
    create_instance(async)                  → Tier 3: durable handle for parallel, fleet-wide work
    

    Offrir les trois options ne représente presque aucun surcoût, pourtant l’écart entre elles représentait 55 % du coût total dans une tâche de clonage. En se limitant au premier niveau, l’agent CLI a dû créer son propre mécanisme de tentative, au prix de 14 108 tokens de sortie.

    Insérer l’ID de l’opération dans le corps JSON

    Le REST classique place les liens des opérations dans des en-têtes tels que Location ou Operation-Location. Les couches modernes de appel d’outils, y compris MCP, OpenAI Tools et LangChain, suppriment souvent les en-têtes HTTP et ne transmettent au modèle que la charge utile JSON.

    Lorsque l’ID fait défaut dans le corps de la requête, le modèle ne génère pas d’erreur visible. Il passe alors par une consultation directe de la ressource cible au lieu de vérifier l’opération. Cela est plus coûteux et moins fiable, car les points d’accès aux ressources renvoient souvent des erreurs 404 ou des données obsolètes lors de l’initialisation, rendant le traitement actif indiscernable d’une erreur. Lors d’une exécution, cela a entraîné 221 appels répétés à get_instance.

    Ajouter des délais d’attente explicites avec des résultats partiels structurés

    Le blocage indéfini présente un risque réel : pertes de connexion, coupures imposées par le balanceur de charge après 300 secondes, et tâches bloquées définitivement. L’outil de mise en attente présentant le coût global le plus bas ne disposait d’aucun délai d’attente et s’est bloqué pendant seize minutes dans un cas, ne laissant à l’agent aucune solution de secours en cas de blocage de la requête.

    La solution consiste en un paramètre timeout_seconds, dont la valeur par défaut est d’environ 300. Lorsque cette limite est atteinte, il convient de retourner un état structuré qui ne constitue pas une erreur, plutôt que de lancer une exception :

    {
      "done": false,
      "operation": "operations/abc-123",
      "elapsed_seconds": 300,
      "status": "RUNNING",
      "metadata": { "percent_complete": 65 }
    }
    

    Désormais, le modèle peut examiner l’avancement et décider s’il faut attendre à nouveau, mettre le travail en arrière-plan ou informer l’utilisateur, sans déclencher de routines de gestion des erreurs. Ce seul critère permet de distinguer une attente bloquante d’une action à risque.

    Conception pour les tâches et les mécanismes asynchrones

    Un auteur de serveur qui implémente MCP bénéficie de la forme standardisée du troisième schéma grâce à l’extension Tasks. Plusieurs points sont importants :

    • Permettre au serveur de déterminer le chemin d’exécution. Les tâches sont gérées par le serveur. Annoncer io.modelcontextprotocol/tasks et retourner un CreateTaskResult plutôt qu’un résultat normal chaque fois qu’une requête risque de durer longtemps. Ne pas exiger que les appels fournissent un indicateur asynchrone, car le client choisit cette option lors de la négociation des capacités.
    • Renvoyer des métadonnées structurées concernant la gestion : une taskId, un statut initial, des valeurs ttlMs et pollIntervalMs, et s’assurer que la tâche a bien été créée de manière persistante avant l’envoi de la réponse. Cela permet aux outils de suivre l’avancement sans déclencher le modèle, et aux clients de se remettre en état après une panne.
    • Prendre en charge les notifications de fin de traitement. Lorsque le transport le permet, utiliser des notifications push ou des tâches au lieu de compter sur les requêtes de suivi côté client. Le suivi par requêtes reste une solution de secours, mais les notifications éliminent les allers-retours inutiles.
    • Conserver l’état des tâches et des opérations terminées pendant au moins 24 à 48 heures. Si le contexte d’un agent est compressé pendant une attente et qu’il effectue par la suite une requête pour un travail terminé, il doit recevoir le résultat et non une erreur 404.

    Compter les schémas

    Chaque outil ajoute des coûts à chaque étape de chaque tâche, y compris celles qui ne l’utilisent jamais. Le coût est approximativement égal au nombre d’étapes multiplié par la taille du contexte. Une attente bloquante améliore le premier facteur, tandis qu’un surdimensionnement du schéma peut annuler cet avantage grâce au second. Un serveur ayant le moins d’étapes peut néanmoins consommer le plus de tokens si de grands schémas d’outils sont présents dans le contexte à chacune d’elles. Avec une grande surface d’outils, le chargement des définitions sur demande, l’utilisation de compétences ou l’ajout de fonctionnalités de recherche d’outils permettent de maintenir un schéma toujours présent de petite taille.

    En résumé

    L’attente est une décision architecturale qui influence les coûts d’un agent, et non une simple optimisation mineure. Remplacer les requêtes gourmandes en tokens par des attentes hiérarchisées, bloquantes ou basées sur des tâches réduit les coûts supplémentaires, et des surfaces d’outils plus légères aident les agents à s’échelonner sans devoir faire appel à un modèle spécialisé pour compter les secondes.