Morgan Dutemple
← Retour au blog
Delivery

Agents IA : quand remplacer une tâche répétée par un script

Schéma en isométrie : à gauche, un robot tourne en boucle sur la même étape et dépense des jetons ; au centre, une barrière pose trois questions (l'étape revient, vérifiable sans le modèle, stable dans le temps) ; à droite, un aiguillage mène à un outil testé que l'agent appelle, au modèle pour le jugement ou les cas ambigus, ou à un sablier pour attendre que la règle se stabilise.
Morgan Dutemple
·Delivery Manager, conduite du changement & IA

Le 1er novembre 2026, Supersocks a résumé sur X une règle que beaucoup d'équipes appliquent sans la nommer : « une étape qui revient, et dont on peut vérifier le résultat sans le modèle, doit devenir du code ». Il répondait à Harper Carroll, pour qui l'époque où l'on maximise la consommation de jetons touche peut-être à sa fin.

Je trouve cette règle utile bien au-delà des développeurs. Elle répond à une question de pilotage : à quel moment un agent IA cesse d'être un terrain d'exploration et devient une dépense récurrente qu'on pourrait éviter ? Je la reprends ici avec mes lunettes de chef de projet, puis je l'éprouve sur deux cas : mon site et un outil de rétro-ingénierie.

Le principe en deux temps : explorer, puis figer

Supersocks décrit deux phases. Au début d'un problème, on ne sait pas encore quelles étapes comptent ni où ça casse. Il faut alors, selon lui, « dépenser des tokens sans remords ». L'agent sert à apprendre, et ses erreurs aussi.

Puis un motif apparaît. Le même contrôle, la même extraction, la même mise en forme reviennent d'une session à l'autre. Les confier encore au modèle, c'est payer à nouveau un raisonnement déjà fait. Avec un risque en prime : que le modèle le refasse autrement cette fois-ci.

À ce stade, on écrit l'étape une fois, on la teste, et on en fait un outil. L'agent l'appelle au lieu de la réinventer. Ce qui reste ambigu, rare ou changeant peut rester une conversation.

Ce découpage n'a rien de neuf pour qui pilote des projets. C'est le passage du prototype au produit. Ce qui change, c'est le coût de l'hésitation : un agent qui refait le même calcul à chaque session facture ce calcul à chaque session.

Ce que le modèle garde

Figer une étape ne retire pas le modèle du circuit. Cela le recentre. Il garde ce qu'un script ne sait pas faire : arbitrer entre deux options défendables, interpréter une demande floue, traiter un cas qui ne s'est présenté qu'une fois, s'adapter à une règle qui bouge encore.

Le critère décisif est la vérifiabilité. Si je peux dire sans le modèle si le résultat est juste, l'étape est candidate. Un titre fait 60 caractères ou il ne les fait pas. Un contraste atteint 4,5:1 ou il ne l'atteint pas. En revanche, « ce titre donne-t-il envie de lire ? » demande encore du jugement. Je le laisse au modèle, ou à moi.

Pourquoi le cadrage permet un modèle plus petit

Supersocks ajoute un point que je trouve sous-estimé. Même les étapes qui gardent un modèle profitent du cadrage. Une fois l'entrée au format fixe et la sortie contrôlable, il n'est plus nécessaire de recourir au modèle le plus puissant. Un petit modèle suffit souvent, « parce qu'on ne lui demande plus de deviner ce qu'on attend de lui ».

C'est un argument de chef de projet autant que d'ingénieur. Un modèle puissant compense une consigne floue. Un modèle modeste exige une consigne nette. Investir dans le cadrage, c'est donc acheter le droit de payer moins cher chaque appel. Je retrouve là une conviction que je défends ailleurs : la dette de cadrage coûte plus cher que la dette technique, et elle se paie aussi en jetons.

Premier exemple : mon propre site

Mon site, morgandutemple.fr, est développé en grande partie avec des agents de code. Je n'ai pas mesuré les jetons économisés ni le temps gagné, et je ne vais pas en inventer. Je peux en revanche montrer ce que le dépôt contient, parce que le mouvement décrit par Supersocks y est visible.

À la racine, un fichier AGENTS.md fixe les règles pour tout agent de code qui travaille sur le site. Deux phrases y résument la logique. Pour les métadonnées des articles : « Compter les longueurs avec un script. » Pour le code : « Les parties pures d'un module se vérifient par un script de ce type. » Autrement dit, je n'attends pas du modèle qu'il compte des caractères de tête. Je lui demande de lancer un programme qui compte.

Le dossier scripts/ contient aujourd'hui 25 scripts de contrôle nommés check-*.ts, que l'agent exécute en une commande. Trois exemples montrent la variété de ce qui a été figé.

check-titres-longueur.ts contrôle les balises de titre et les meta descriptions des pages générées. Ses règles bloquantes sont écrites noir sur blanc : un titre de 60 caractères au plus, pas de nom de marque en double, une meta description de 160 caractères au plus.

check-contrastes-signalisation.ts recalcule les contrastes de couleurs à partir des valeurs réelles de la feuille de style, dans le thème clair et le thème sombre. Il applique les seuils WCAG : 4,5:1 pour le texte, 3:1 pour les éléments graphiques. Un modèle peut se tromper sur un calcul de luminance relative. Le script, une fois testé, ne se trompe pas de la même façon deux fois.

check-blog-dates.ts vérifie une règle simple et facile à oublier : la date de modification d'un article ne précède jamais sa date de publication. Le script enchaîne sept vérifications, dont les cas où une donnée manque ou est illisible.

D'autres outils ne contrôlent pas, ils produisent. gen-audio.mjs génère la narration audio d'un article par synthèse vocale. Il retire lui-même la section « Questions fréquentes », la ligne des sources et le bloc « Pour aller plus loin », selon une convention fixe établie sur le corpus existant. unsplash-search.mjs cherche des photos uniquement par l'API officielle et sort tout ce dont le site a besoin : URL de rendu, photographe, liens d'attribution. Ni l'un ni l'autre ne laisse au modèle le soin de décider comment découper un texte ou formater une attribution.

Ce qui reste à l'agent, c'est le reste : rédiger, proposer une structure, choisir une photo pertinente parmi les résultats, arbitrer quand deux règles se contredisent. Le jugement, donc.

Second exemple : REA, la rétro-ingénierie outillée

Supersocks cite un cas plus spectaculaire : REA, pour « Reverse Engineer Anything ». La rétro-ingénierie consiste à comprendre un logiciel à partir de ce qui est livré, sans son code source. Avec un agent lâché dans un terminal, c'est une suite sans fin de commandes et de sorties de milliers de lignes à relire. Un gouffre à jetons.

Le dépôt public de REA, sous licence MIT, se présente comme un serveur MCP et une interface en ligne de commande qui permettent à un agent de piloter des moteurs de rétro-ingénierie existants. D'après sa documentation, l'analyse des binaires natifs s'appuie sur Hopper, Ghidra, IDA ou Kuna, et celle des applications Android sur JADX. Ces moteurs font le calcul lourd sans aucun modèle. L'agent choisit la cible, enchaîne les outils et interprète. La documentation précise que les résultats arrivent avec les preuves et les limites qui fondent chaque conclusion.

Supersocks parle d'environ deux cents outils précis. Je n'ai pas pu vérifier ce nombre dans le dépôt : le catalogue y est généré à la compilation et n'est pas versionné. Je le lui attribue donc.

Le point qui m'intéresse est la preuve. Quand l'agent se trompe, la sortie structurée de l'outil est là pour le contredire. C'est exactement ce que je cherche avec mes scripts de contrôle : un arbitre qui ne dépend pas du modèle.

Côté cadre légal, le projet indique qu'il est destiné à la recherche légale, à l'enseignement, à l'interopérabilité, à la préservation des logiciels ou à l'analyse de logiciels que l'on possède ou que l'on est autorisé à examiner.

Les limites à garder en tête

Figer trop tôt est le premier piège. Une méthode encore mal comprise, gravée dans le code, devient une erreur qu'il faut maintenir. Tant que les cas varient d'une session à l'autre, je préfère laisser l'étape dans la conversation.

Le deuxième est la maintenance. Un script est un actif, mais aussi une dette. Il casse quand la structure qu'il lit change. Chacun de mes 25 scripts de contrôle doit suivre l'évolution du code qu'il vérifie. Un outil qu'on n'entretient plus finit par donner une fausse assurance.

Le troisième tient au contexte. Chaque outil exposé à un agent s'accompagne d'une description qui occupe de la place dans sa fenêtre de contexte. Supersocks le souligne : deux cents descriptions, ce n'est pas gratuit. La documentation de REA confirme le problème à sa façon, puisque le serveur utilise par défaut des schémas d'entrée compacts « pour réduire la charge de contexte ». Un catalogue d'outils doit donc rester sélectif.

Le quatrième est économique. Supersocks rappelle que les fournisseurs de modèles sont payés au jeton. Ils n'ont pas d'intérêt direct à ce que vous consommiez moins. L'envie d'économiser viendra de ceux qui paient, pas de ceux qui encaissent. Pour un chef de projet, cela veut dire que personne d'autre que vous ne fera cet arbitrage.

Ce qu'un chef de projet peut en retenir

Je propose une grille en trois questions, à poser à chaque étape confiée à un agent.

L'étape revient-elle ? Si elle n'est apparue qu'une fois, laissez-la au modèle. Elle n'a pas encore assez d'histoire pour être figée.

Son résultat est-il vérifiable sans le modèle ? Si un programme peut dire « juste » ou « faux », l'étape est candidate. Si seul un humain ou un modèle peut en juger, elle reste une conversation.

Est-elle stable ? Si la règle change encore chaque semaine, attendez. Un outil figé sur une règle mouvante coûte plus en maintenance qu'il ne rapporte.

Trois oui : écrivez l'outil, testez-le, et faites-en une consigne dans le fichier de règles de vos agents. Un non : gardez l'étape dans la conversation et notez-la pour la revoir plus tard.

Cette grille n'a rien d'exotique pour qui fait de la conduite du changement ou du delivery. On explore d'abord, on industrialise ensuite. On ne rédige pas une procédure avant d'avoir compris le métier, et on ne laisse pas un prototype en production indéfiniment. La seule nouveauté tient au compteur : avec un agent, chaque hésitation à industrialiser se paie à l'usage.

Supersocks conclut par une question que je trouve juste : avant de relancer un agent pour la troisième fois sur la même tâche, qu'avez-vous appris les deux premières fois, et quelle part peut devenir un outil ? C'est une bonne question de rétrospective, avec ou sans IA.

Sources :

Pour aller plus loin

Questions fréquentes

Qu'est-ce qu'un « outil » pour un agent IA ?

C'est un programme que l'agent peut appeler plutôt que de raisonner lui-même. Il a une entrée définie, une sortie définie et des tests. L'agent décide quand l'appeler et interprète le résultat, mais il ne refait pas le calcul.

Faut-il tout transformer en code dès le départ ?

Non. Au début d'un problème, on ne sait pas encore quelles étapes reviennent ni où sont les cas limites. Figer trop tôt grave une méthode encore fausse. L'exploration par l'agent sert justement à découvrir ce qui mérite d'être figé.

Pourquoi un modèle plus petit suffit-il quand la tâche est cadrée ?

Parce qu'on ne lui demande plus de deviner l'attente. Avec une entrée au format fixe et une sortie contrôlable, la tâche devient plus simple. La puissance d'un grand modèle sert surtout à compenser une consigne floue.

Combien d'outils exposer à un agent ?

Le moins possible pour la tâche en cours. Chaque outil ajoute une description dans le contexte de l'agent, ce qui a un coût et peut brouiller son choix. REA, par exemple, compacte par défaut les schémas d'entrée de ses outils pour limiter cette charge.

Comment repérer une étape candidate dans mon projet ?

Posez trois questions : revient-elle d'une session à l'autre, son résultat se vérifie-t-il sans le modèle, la règle est-elle stable ? Trois oui signalent une étape à transformer en outil.

Morgan Dutemple

À propos de l'auteur

Morgan Dutemple

Delivery Manager à Rennes. Je pilote des projets de transformation digitale, SEO/GEO et accessibilité RGAA pour des clients grands comptes. Ce blog est le reflet de ce que je rencontre sur le terrain.