Accueil / Articles

Votre structure d’agent est probablement surdimensionnée : ce qu’il faut supprimer.

Votre harnais d’agent est probablement surdimensionné. À mesure que les modèles s’améliorent, les structures d’accompagnement deviennent un fardeau inutile. Comment réduire l’encombrement des évaluations et le coût lié au contexte, ainsi que ce qu’il convient de supprimer.

Éditeur : REACTAPP.TOP9 min de lecture2154 mots

Sources: Your Agent Harness Is Probably Overengineered

À mesure que les agents deviennent plus intelligents, le travail utile se déplace vers l’extraction d’informations d’eux. Cela va à l’encontre de ce que les équipes ont fait au cours de l’année écoulée, à savoir ajouter de nouvelles compétences et capacités de manière supplémentaire.

Presque tous les progrès réalisés jusqu’à présent avec les agents proviennent de structures d’appui : étapes de planification, boucles de vérification, compétences, mémoire, points d’ancrage. Lorsque les modèles étaient moins performants, cela avait du sens, car ces structures compensaient ce que le modèle ne pouvait pas faire seul. Le problème, c’est que personne ne les supprime une fois que le modèle rattrape son retard. Une limitation apparaît, une solution de contournement est créée, et cette solution reste en place à jamais. Il s’agit d’une dette technique propre aux agents, qui nuit fréquemment aux résultats.

Lorsque le support technique s’oppose au modèle

Considérez une configuration ajustée pour les 4,5e et 4,6e générations d’une famille de modèles. Elle planifiait, vérifiait son propre travail et effectuait des vérifications supplémentaires avant de répondre, ce qui était un bon équilibre à l’époque. Si l’on transfère cette même configuration à une génération plus récente, elle devient un obstacle. Le modèle raisonne déjà de cette manière sans aucune incitation, pourtant le système lui demande toujours de douter de lui-même, de tout revoir et de recommencer. Il planifie, puis reconsidère son plan. Il exécute, puis remet en question son exécution. Il vérifie, puis discute des résultats de la vérification. Bientôt, l’agent se retrouve bloqué dans une paralysie analytique et passe des ressources à remettre en cause des décisions qui étaient tout à fait correctes. C’est un pas en avant et un pas en arrière, avec davantage de raisonnement qui ne produit pas de meilleure réponse et parfois même une réponse pire.

Jusqu’à présent, il ne s’agit que d’une impression ; voici donc quelque chose de mesurable. Un ingénieur conserve depuis des mois un modèle de revue avant déploiement qui a été constamment modifié. Il comptait initialement 22 lignes et en compte maintenant 37, avec le nombre de types de revues passant de deux à trois. Rien n’a jamais été supprimé. Chaque ajout correspondait à une règle, et chaque règle a été ajoutée parce qu’un problème réel était apparu dans une demande de fusion. De l’intérieur, c’est ainsi que se manifeste le surdimensionnement inutile. De bonnes intentions sont ce qui fait que les systèmes deviennent encombrants. Chaque modification résolvait bien un problème réel au moment où elle était apportée, mais l’étape suivante manquait : personne ne revenait plus vérifier si cette règle restait utile. Personne ne s’occupait de l’affiner.

Anthropic a rencontré le même problème. Dans son article technique de avril 2026 sur l’optimisation des agents gérés, il est indiqué que les outils de gestion codent des hypothèses concernant ce que un modèle ne peut pas faire seul, et ces hypothèses deviennent obsolètes à mesure que les modèles s’améliorent. Ils donnent l’exemple de Sonnet 4.5, qui termine prématurément lorsqu’il perçoit que la limite de contexte est atteinte, un comportement qu’ils qualifient d’anxiété de contexte. Ils ont ajouté des réinitialisations de contexte pour y remédier. Avec Opus 4.5, ce comportement a disparu et les réinitialisations sont devenues inutiles.

Cela entraîne une habitude pratique : lorsqu’un nouveau modèle arrive, il convient de lui demander d’auditer ses outils de gestion existants avant qu’il ne prenne en charge de nouvelles tâches.

Plus d’analyses ne signifie pas plus d’informations utiles

Demander à un agent d’effectuer des analyses supplémentaires épuise discrètement les informations utiles, et cela se produit plus fréquemment que les gens ne l’imaginent.

La revue de code le montre bien. On indique à un agent un certain code et on lui demande de rechercher des problèmes, et c’est bien des problèmes qu’il retourne. Certains sont importants. D’autres ne sont que des remarques sur le style, des cas limites hypothétiques ou des affirmations techniquement vraies mais hors sujet. L’agent ne fait pas d’erreur ici, car vous avez demandé des problèmes et il vous les a fournis. Certaines constatations sont simplement fausses, ce qui constitue un problème en soi, mais celles qui coûtent cher sont des constatations correctes mais sans importance.

Les problèmes commencent quand elles s’accumulent. Lorsqu’il y a dix problèmes plausibles, la question n’est plus de savoir si chacun tient la route, mais plutôt lesquels sont importants. Un système de revue peut donc vous fournir à la fois plus d’informations et moins de signaux pertinents.

Un cas concret illustre bien cela. Une demande de ticket exigeait qu’un point de terminaison renvoie un code 409, mais il renvoyait en réalité un code 500. La correction minimale nécessitait seulement deux lignes dans un seul fichier. En revanche, la proposition de modification retournée concernait 13 fichiers et près de 500 lignes réparties sur trois services. Une grande partie de ce contenu était constituée de tests, donc ce n’était pas entièrement inutile, mais c’était néanmoins considérable. Six agents spécialisés dans l’examen des modifications avaient examiné les changements, chacun effectuant sa tâche et identifiant des problèmes réels, et l’agent principal a appliqué toutes ces corrections, ce qui a fait gonfler considérablement la proposition de modification. Une personne a remarqué cet excès, a rédigé la correction en deux lignes, et cette version a été fusionnée. La proposition de modification trop volumineuse a alors été fermée.

Aucun des reviewers n’a échoué. Les 13 fichiers ne représentaient jamais une seule décision ; il s’agissait de treize décisions justifiables qui n’avaient pas été additionnées. Chaque reviewer s’est demandé si le code était correct, mais aucun n’a cherché à savoir s’il devait exister.

Abandonner un évaluateur n’était pas la solution. L’équipe a donné à un nouvel évaluateur des instructions opposées : traiter la différence comme quelque chose qui ne devrait probablement pas exister, et obliger l’auteur à défendre chaque fichier pour le conserver. CUT était la valeur par défaut. Ce qu’il indique, c’est un seul ratio, entre les fichiers soumis et le nombre minimum requis, et ce chiffre permet de déterminer si la modification est de la bonne taille.

L’analyse en masse ne coûte rien. Le signal est la partie rare, et un modèle plus performant ne le fournit pas gratuitement.

Anthropic a également rencontré ce problème. Son article de mars 2026 sur la conception des outils pour les applications à long terme explique pourquoi l’agent de codage et son évaluateur ont été séparés. Lorsqu’on demande aux agents d’évaluer leur propre travail, ils ont tendance à le louer avec assurance, même lorsque quelqu’un de humain jugerait sa qualité simplement médiocre. Un évaluateur distinct peut être incité à être sceptique, tandis qu’un agent capable de s’évaluer lui-même ne le peut pas. Cependant, l’utilité de cet évaluateur dépendait de la tâche : pour les tâches simples, il ne faisait qu’ajouter une charge inutile, tandis que pour les tâches difficiles, il apportait une véritable aide.

Le fossé entre un agent actif et un agent utile s’élargit dès qu’il fonctionne toute la journée.

Un agent toujours actif ne devrait pas être constamment en train de réfléchir

Prenez un agent conçu pour une rotation de gardes. Il surveille les canaux d’ingénierie et met en évidence tout ce que la personne de garde devrait savoir. Ces canaux sont très actifs et aucun humain de service ne lit tous les messages, donc un agent actif 24/7 peut repérer ce que l’humain manquerait.

La première version était surdimensionnée : outils pour les périodes de maintenance, introspection des services, requêtes de politique d’escalade et un manuel indiquant quand utiliser chacun d’eux. Le développeur a appelé cela « on-call maxxing » et a arrêté son travail en cours de route. Les exigences réelles se résumaient à deux points : répondre rapidement aux incidents afin que personne ne soit alerté, et surveiller suffisamment les canaux pour que les problèmes réels soient identifiés tôt. Pour répondre, un seul commandement sans arguments suffisait. Le reste n’ajoutait rien et a été supprimé.

Peu de temps après, la même erreur est réapparue à un niveau inférieur, au sein même de l’architecture. Un chronomètre déclenchait la boucle toutes les dix minutes pendant chaque quart de travail, et une session continuait à collecter des données contextuelles. Chaque passage relisait donc un transcript de plus en plus long, comptabilisé comme des lectures dans le cache Opus ; à la fin d’un quart de travail, sa longueur dépassait les 150 000 tokens. Sur toute la période mesurée, le compte aurait engendré 2,1 milliards de tokens de lectures dans le cache, ce qui équivaut à environ 1 050 dollars selon les tarifs de l’équipe. Un forfait forfaitaire évitait une facturation directe, mais la limite hebdomadaire était atteinte même avec une promotion ajoutant 50 %. L’analyse de la consommation a permis d’identifier directement la cause du problème.

Une instruction plus précise n’a pas été la solution ; un design différent l’a été. À chaque itération, la boucle génère désormais un agent Sonnet à durée de vie courte dont la tâche est simple : lire tout ce qui est nouveau, enregistrer l’heure de dernière vision pour chaque canal dans un petit fichier, et renvoyer une seule ligne. Comme la session propre à la boucle reste simple, le modèle coûteux ne s’exécute que lorsque le modèle simplifié ne suffit plus. En termes de code, cela a permis d’éliminer 79 lignes ainsi qu’un composant entier. La prochaine période de travail s’est déroulée sans rien d’important manqué, et la surveillance se poursuit.

On estimait qu’une itération ordinaire passerait d’environ 0,25 $ à environ 0,03 $. En comparant 433 itérations du design ancien avec une période complète de travail avec le nouveau design, on a obtenu le bon rapport à une échelle différente : environ 1,85 $ par itération avant et environ 0,19 $ après, soit une économie d’environ dix fois. La nature du problème avait été correctement jugée, mais son ampleur avait été sous-estimée.

Ce qui est intéressant, c’est ce qui n’a pas causé la hausse des coûts. La conception initiale utilisait déjà un modèle bon marché, Haiku, pour la lecture effective des canaux, et celui-ci ne représentait pas plus de 1 % des lectures dans le cache. Le coût réel provenait de la session parente qui devait relire son propre enregistrement en constante augmentation à chaque passage. Le modèle bon marché effectuait le travail, tandis que le modèle coûteux devait tout relire à nouveau.

Deux leçons en ressortent. Premièrement, veillez à ce que le modèle coûteux ne répète pas le travail déjà accompli par le modèle bon marché. Deuxièmement, pour une tâche à haute fréquence et à faible enjeu, un modèle plus puissant ne rapporte presque rien ; il devient utile uniquement lorsqu’il s’agit de gérer un incident complexe en production. Le modèle le plus intelligent n’a pas nécessairement besoin d’être le plus sollicité.

Le contexte n’est pas gratuit

Le désir de sur-engineer augmente à mesure que les fenêtres de contexte s’élargissent. Lorsque le contexte était limité, le choix était forcé. Aujourd’hui, il est facile de considérer le contexte comme un espace de stockage : on y ajoute la conversation, les documents, les descriptions des outils, l’historique ainsi que toutes les compétences qui pourraient être utiles, puis on laisse le modèle s’en occuper. Le modèle ne perçoit pas le contexte comme un stockage ; tout fait partie du problème à résoudre. Chaque instruction représente un élément supplémentaire à interpréter, et chaque outil est une ressource supplémentaire dont il peut se servir. Un agent plus intelligent, tout comme une personne plus intelligente, a besoin de plus de concentration et non de plus d’informations.

Cela soulève une question à poser à tout agent : qu’est-ce qui pourrait être ajouté sans aggraver la situation ? Plutôt que d’écrire une nouvelle compétence, supprimez-en une. Fonctionnez avec moins de contexte que ce qui vous semble sécuritaire. Éliminez un cycle de vérification. Effectuez des sondages à un rythme plus lent. Laissez ensuite les résultats parler d’eux-mêmes. Si rien ne se détériore, l’agent devient moins coûteux sans aucun sacrifice et est probablement même meilleur, puisque le modèle a moins de données à traiter. S’il y a une détérioration, vous aurez appris que cette composante n’a pas sa place dans ce modèle.

De la maximisation de tout à l’ingénierie agente

Derrière tout cela se cache une habitude : les équipes sont devenues expertes dans l’optimisation de tout – plus de tokens, de contexte, de compétences, d’outils, de mémoire, d’éléments de connexion, de capacités de raisonnement, de vérification et de sous-agents. Ajouter davantage de composants donne l’impression d’avancer, car le système devient plus complexe, mais complexe et utile ne sont pas des synonymes. À un certain stade, on crée une bureaucratie autour de l’agent, et les bureaucraties sont généralement gaspilleuses.

Considérez chaque élément d’un harnais comme une hypothèse, par exemple :

  • Cette compétence permet à l’agent d’écrire de meilleurs codes.
  • Cet élément de connexion empêche les véritables pannes.
  • Une nouvelle vérification permettra de détecter les erreurs que l’agent principal a manquées.
  • Plus de sous-agents permettront d’achever le travail plus rapidement.

Ce qui semble utile n’est en réalité qu’une supposition concernant votre système, et non un fait. Il est impossible d’éviter l’étape fastidieuse qu’est l’expérimentation : exécutez le processus avec et sans cette compétence, puis avec et sans cet élément supplémentaire, et mesurez les résultats.

Le post de design d’Anthropic expose directement ce principe : chaque composant d’un système intégré repose sur une supposition quant à ce que le modèle ne peut gérer seul, et ces suppositions doivent faire l’objet de tests de résistance. Son équipe a d’abord conçu un système complexe qui fonctionnait, puis a retiré progressivement des éléments pour déterminer lesquels étaient essentiels. La décomposition en sprints a été abandonnée, car les améliorations apportées dans Opus 4.6 donnaient de bonnes raisons de penser que le modèle pouvait effectuer cette tâche de manière native.

Cela enseigne bien plus que le slogan selon lequel seuls des agents simples gagnent. Considérez un ensemble d’outils comme quelque chose que l’on mesure et que l’on ajuste. Quelques composants deviennent inutiles, d’autres restent car le modèle ne peut toujours pas accomplir cette tâche. Supprimer un élément et prouver que personne ne s’en est aperçu est plus difficile que d’en ajouter un, et c’est là que se situe la frontière entre l’optimisation absolue et l’ingénierie agente. L’une vise à maximiser ce que fait le système, l’autre à maximiser le signal utile pour chaque token dépensé.

Aiguiser la hache

Au fur et à mesure que les modèles s’améliorent, la liste des éléments à supprimer s’allonge. Les tâches qui nécessitaient auparavant des supports temporaires deviennent progressivement autonomes, les boucles de révision cessent d’être justifiées par leur coût, et une partie de ce qui semblait fondamental s’avère n’être qu’un correctif pour un modèle obsolète. Un ensemble d’outils n’est jamais achevé. Se demandez simplement si un élément améliore encore les résultats pour ce modèle et cette tâche, mesurez-le, supprimez-le, et ne le réintégrez que lorsque les preuves montrent qu’il est essentiel.

On prête souvent à Lincoln cette citation : s’il devait couper un arbre en six heures, il passerait les quatre premières à aiguiser la hache. Aiguisez la hache.

Lectures complémentaires

  • DeepSeek Harness (dsh) : l’environnement d’exécution d’agent ouvert qui réécrit sa propre configuration — Qu’est-ce que DeepSeek Harness, pourquoi son agent capable de s’auto-éditer se distingue, comment la communauté a réagi, et à quoi se préparer avant de l’exécuter avec des modèles locaux.