Guide de terrain · octobre 2026

Agents en production

Livrer des agents IA qui survivent au lundi matin
par Mat Siems
Partie I

Le rez-de-chaussée

Ce qu'est un agent : un modèle, des outils et une boucle.

Chapitre 1 · Partie I

La démo est une menteuse

Tout projet d'agent commence par une démo, et toute démo est un petit mensonge bien intentionné. Quelqu'un tape une requête soigneusement choisie sur un portable au fond d'une salle, l'agent cherche, raisonne, appelle trois outils et produit quelque chose qui fait se redresser le directeur des opérations. Applaudissements. Une ligne budgétaire apparaît. Puis quelqu'un pose la question raisonnable : peut-on l'avoir en production d'ici le prochain trimestre ? Ce livre s'adresse à la personne qui doit répondre honnêtement à cette question.

La démo n'est pas malhonnête parce que quelqu'un a triché. Elle l'est à cause de ce qu'elle passe sous silence. Elle a tourné une fois, sur une entrée que son auteur avait essayée une douzaine de fois. Les données étaient propres, les API répondaient, la demande était sans ambiguïté et la personne qui regardait voulait que ça marche. Personne ne lui a demandé de gérer un client qui écrit en trois langues, une base de données qui expire à neuf heures du matin, un outil qui renvoie une page d'erreur HTML au lieu de JSON, ou une demande techniquement autorisée et manifestement imprudente. Personne ne l'a fait tourner dix mille fois en comptant.

La production pose exactement ces questions, et les pose le lundi matin, quand la file d'attente est pleine et que la personne qui a construit l'outil est dans un train. L'écart entre la démo et la production n'est pas un écart d'intelligence du modèle. Le modèle de la démo est celui que vous allez livrer. L'écart, c'est tout ce qui l'entoure : comment l'agent reçoit ses outils, ce qu'il voit, ce dont il se souvient, ce qui se passe quand une étape échoue, qui peut l'arrêter, combien il peut dépenser, comment vous découvrez ce qu'il a fait, et comment vous savez si la version de cette semaine vaut mieux que celle de la semaine dernière.

Une démo prouve que quelque chose peut arriver. La production a besoin de savoir à quelle fréquence.

Ce glissement de peut à à quelle fréquence, c'est toute la discipline. Un agent qui réussit quatre fois sur cinq est une merveille sur scène et un risque dans un service de sinistres. Le cinquième cas, c'est là que vivent vos clients, avec vos auditeurs et, tôt ou tard, vos avocats. Votre travail consiste à découvrir à quoi ressemble ce cinquième cas, à le rendre plus rare, à le rendre moins coûteux quand il survient, et à vous assurer que quelqu'un le remarque.

Voici de quoi vous occuper cette semaine. Prenez le prototype d'agent qui enthousiasme le plus votre organisation et écrivez, en phrases simples, les dix entrées les plus susceptibles de l'embarrasser. Pas du génie malveillant, juste le désordre ordinaire : la demande vague, la pièce jointe énorme, le champ manquant, le client furieux, la demande qui exige un humain. Lancez chacune. Vous apprendrez davantage en cette heure qu'avec la démo d'origine, et vous aurez le premier jet d'un jeu d'évaluation sans avoir eu l'intention d'en écrire un. La démo, c'était la bande-annonce. La production, c'est le film, et personne ne quitte la salle plus tôt parce que la bande-annonce était bonne.

Ce que la démo omet ASPECT La démo Production Runs 1 fois sur une entrée répétée 10 000 fois et quelqu'un compte Entrées Propres et claires choisies par l'auteur Désordre ordinaire vagues, énormes, absentes, fâchées Systèmes Tout est en ligne données propres, API OK Lundi 9 h timeouts, HTML au lieu de JSON Question Est-ce possible ? la bande-annonce Fréquence ? le film Quatre sur cinq, c'est une merveille sur scène et un passif aux sinistres. Dix entrées gênantes Lancez chacune Premier jeu d'éval
Fig. 1 · La démo est une menteuse. Ce que cache une démo, et comment dix entrées gênantes deviennent un premier jeu d'évaluation.
Chapitre 2 · Partie I

Modèle, outils, boucle

Les définitions sont glissantes dans ce domaine, et les définitions glissantes produisent des systèmes glissants ; fixons-en donc une dès maintenant. Un agent, c'est un modèle, un ensemble d'outils et une boucle. Le modèle lit la situation et décide quoi faire ensuite. Les outils lui permettent de faire autre chose que produire du texte : chercher, lire un enregistrement, exécuter du code, envoyer un message. La boucle renvoie le résultat de chaque action au modèle et lui redemande, jusqu'à ce que le modèle se déclare terminé ou que quelque chose d'extérieur lui dise d'arrêter.

C'est tout. Il vaut la peine d'être clair là-dessus, car la littérature des fournisseurs et les conférences vous proposeront des agents dotés de personnalités, d'objectifs, de carrières. Retirez les adjectifs et vous retrouvez les trois mêmes pièces. Si un système a un modèle mais pas d'outils, c'est un chatbot. S'il a des outils mais que le chemin est figé dans le code, c'est un workflow qui se trouve appeler un modèle. Si le modèle choisit l'outil suivant en fonction de ce que le précédent a renvoyé, vous avez un agent, et vous avez endossé les responsabilités particulières qui vont avec le fait de laisser un logiciel décider de sa prochaine étape.

Chaque pièce échoue différemment, ce qui est la raison pratique de les garder séparées dans votre tête. Le modèle échoue par incompréhension : il choisit le mauvais outil, invente un paramètre ou crie victoire trop tôt. Les outils échouent comme n'importe quel logiciel : délais dépassés, permissions, données mal formées, effets de bord irréversibles. La boucle échoue en ne finissant jamais, ou en finissant au mauvais moment, ou en exécutant la même étape quarante fois pendant que le compteur tourne. Quand quelque chose tourne mal en production, votre première question de diagnostic est de savoir laquelle des trois pièces est en cause. La plupart des équipes accusent d'instinct le modèle. La plupart du temps, c'étaient les outils ou la boucle.

Le modèle, vous le louez. Les outils et la boucle, vous en êtes propriétaire.

Cette phrase porte beaucoup de poids dans les chapitres qui suivent. Vous pouvez choisir un meilleur modèle, et il le faut parfois. Mais vous ne pouvez pas rendre le modèle d'un fournisseur plus fiable à force de le souhaiter. Ce que vous pouvez faire, c'est concevoir des outils difficiles à mal utiliser, écrire une boucle qui connaît ses limites et construire l'échafaudage qui rattrape le modèle quand il trébuche. Ce sont des problèmes d'ingénierie aux réponses d'ingénierie, et c'est là que vos efforts se capitalisent.

Un exercice utile consiste à dessiner n'importe quel agent sur lequel vous travaillez sous forme de trois boîtes. Sous la boîte du modèle, écrivez ce qu'on lui demande de décider. Sous celle des outils, listez chaque action qu'il peut entreprendre, et marquez celles qui changent quelque chose dans le monde. Sous celle de la boucle, écrivez les conditions qui mettent fin à une exécution. Si une boîte est difficile à remplir, c'est là que le prochain incident attend tranquillement. Des définitions simples ne sont pas le signe d'un sujet simple. Elles sont ce qui empêche un sujet difficile de devenir un sujet flou.

Trois parties, trois façons d'échouer Modèle décide l'étape suivante ÉCHOUE PAR Mauvais outil Paramètre inventé Victoire hâtive Outils agissent sur le monde ÉCHOUE PAR Timeouts Données malformées Effets de bord Boucle renvoie les résultats ÉCHOUE PAR Sans fin Finit trop tôt Même étape 40 fois résultat revient, le modèle redemande La partie louée Les parties à vous Chatbot modèle, sans outils Workflow chemin fixé en code Agent le modèle choisit l'outil La plupart des incidents viennent des outils ou de la boucle, pas du modèle.
Fig. 2 · Modèle, outils, boucle. Modèle, outils et boucle échouent chacun à leur façon ; vous louez l'un et possédez les deux autres.
Chapitre 3 · Partie I

La boucle a un corps

Il est utile de ralentir un agent jusqu'à un seul tour et de le regarder de près, comme un mécanicien observe une seule révolution d'un moteur. La plupart des gens imaginent le modèle comme le moteur. En pratique, le modèle n'est qu'un cylindre. Le reste du moteur est un programme que vous écrivez, généralement appelé le harnais, et il fait bien plus de travail que les schémas ne le laissent croire.

Un tour commence par l'assemblage d'une requête par le harnais. Il rassemble le prompt système, la conversation jusque-là, les définitions des outils disponibles et tout contexte récupéré, puis envoie le tout au modèle. Le modèle répond soit par du texte, soit par une demande d'appel d'outil, exprimée sous la forme d'un nom et d'un ensemble d'arguments. Le modèle n'appelle pas l'outil. Il ne le peut pas. Il n'a pas de mains. Le harnais lit cette demande, la vérifie, décide si elle est autorisée, exécute la fonction réelle, capture le résultat et l'ajoute à la conversation. Puis il renvoie le tout au modèle, et le tour suivant commence.

Regardez combien de décisions reviennent au harnais dans cette description. Si l'appel d'outil est valide. Si cet agent a le droit de le faire. S'il faut d'abord l'approbation d'un humain. Combien de temps l'attendre. Que faire s'il échoue. Quelle part d'un résultat énorme renvoyer. Si l'exécution a dépassé son budget. Si la réponse finale revendiquée par le modèle satisfait la définition de « terminé ». Chacune de ces décisions est du code que vous contrôlez, et chacune est un endroit où la fiabilité en production se gagne ou se perd.

Le modèle propose. Le harnais dispose.

C'est le fait architectural le plus important de ce livre, et c'est aussi un soulagement. Il signifie que vous n'êtes pas à la merci de l'humeur d'un modèle. Un modèle qui veut supprimer une table de production ne le peut pas, à moins que votre harnais ne lui confie un outil qui supprime des tables et n'exécute ensuite l'appel sans poser de question. Un modèle qui boucle à l'infini ne le peut pas, à moins que votre harnais n'oublie de compter. La liberté du modèle est exactement aussi grande que le harnais le permet, et le harnais est un logiciel ordinaire avec des tests ordinaires.

Il y a une deuxième conséquence. Quand on dit qu'un agent a « décidé » de faire quelque chose de bizarre, traduisez la phrase. Le modèle a suggéré quelque chose de bizarre et le harnais l'a laissé passer. Cette traduction n'excuse pas le modèle, mais elle indique où se trouve généralement la correction. On parvient rarement, à coups de prompts, à ne jamais rien suggérer de bizarre. On parvient presque toujours, à coups de code, à ne pas y donner suite.

Cette semaine, trouvez dans votre propre système l'endroit où les appels d'outils sont exécutés et lisez-le ligne par ligne. Demandez-vous ce qui se passe si les arguments sont mal formés, si l'outil se fige, si le résultat est un mégaoctet de HTML, si le même appel arrive deux fois. Si la réponse à l'une de ces questions est « je ne suis pas sûr », vous avez trouvé votre prochain petit chantier à forte valeur. Les moteurs sont fiables grâce aux pièces que personne ne photographie.

Un tour, au ralenti Le modèle propose. Le harnais dispose. Harnais votre code Modèle loué Outil vraie fonction 1 Envoi du contexte prompt, historique, outils 2 Demande d'outil un nom et des arguments Le harnais décide arguments valides ? permis pour cet agent ? validation humaine ? budget restant ? timeout, relances 3 Exécution avec un timeout 4 Résultat élagué, ajouté 5 Tour suivant jusqu'à fin ou arrêt le modèle n'a pas de mains
Fig. 3 · La boucle a un corps. Un tour en détail : le modèle demande, le harnais vérifie, exécute et renvoie.
Chapitre 4 · Partie I

L'autonomie est un curseur

Demandez à une salle d'ingénieurs si leur système est « vraiment » un agent et vous lancerez une dispute qui survivra au café. La dispute est en grande partie vaine, car l'autonomie n'est pas une propriété qu'un système possède ou non. C'est un curseur, et vous le réglez par tâche, par niveau de risque et par stade de maturité.

Au réglage le plus bas, le modèle suggère et un humain fait tout. Un cran au-dessus, le modèle rédige un brouillon et un humain le corrige avant que quoi que ce soit ne quitte le bâtiment. Plus haut encore, le modèle agit sur ce qui est réversible et demande avant ce qui ne l'est pas. Plus haut, il agit sur tout dans un périmètre défini et rend compte après coup. Tout en haut, il tourne sans surveillance pendant des heures, choisit ses propres étapes, et les humains ne regardent que les synthèses et les exceptions. Chaque réglage est une conception légitime. Aucun n'est plus avancé au sens moral. La seule question est de savoir quel réglage convient à cette tâche, cette semaine.

Trois choses devraient faire bouger le curseur. La première est la réversibilité. Un agent qui rédige des brouillons de réponses à des e-mails qu'un humain enverra peut se tromper souvent et pour pas cher ; un agent qui émet des remboursements, non. La deuxième est la vérifiabilité. Si le résultat peut être contrôlé automatiquement, par des tests, un validateur ou une comparaison avec une réponse connue, vous pouvez laisser l'agent aller plus loin, parce que vous le rattraperez. Si le seul contrôle est un humain qui lit attentivement, gardez-le plus près. La troisième est l'historique. Un nouvel agent gagne son autonomie comme un nouveau collègue : en ayant raison devant témoins pendant un certain temps.

La confiance ne s'accorde pas dans le document de conception. Elle s'accumule dans les journaux.

L'erreur pratique consiste à choisir un seul réglage pour tout un système. Les vrais agents font beaucoup de choses différentes en une seule exécution. Un agent de support peut consulter une commande, résumer une politique et proposer un geste commercial. Les deux premières actions peuvent tourner en pleine autonomie. La troisième demande probablement un seuil au-delà duquel un humain signe. Concevez le curseur au niveau de chaque action, et non de l'agent entier, et vous découvrirez que vous pouvez livrer bien plus tôt, parce que la partie risquée est clôturée et que la partie utile est libre de travailler.

Il est également payant de rendre le curseur explicite dans la configuration plutôt qu'implicite dans le code. Quand un réglage vit dans un fichier qui dit en substance les remboursements en dessous de tel montant sont automatiques, au-dessus ils attendent une approbation, le métier peut le lire, les auditeurs peuvent le vérifier, et vous pouvez le tourner pendant un incident sans déploiement. Quand la même règle est enfouie dans un prompt, personne ne la trouve, et le modèle peut décider un mardi qu'elle ne s'applique pas.

Commencez cette semaine par dresser la liste de chaque action que votre agent peut entreprendre et attribuez à chacune un réglage du curseur. Puis cherchez les écarts entre l'endroit où se trouve chaque action et celui où elle pourrait être en toute sécurité. En général, quelques-unes peuvent monter et une ou deux devraient descendre. L'autonomie n'est pas une destination. C'est un réglage que vous revisitez, de préférence avant que quelque chose ne le revisite à votre place.

Réglez le curseur par action, pas par agent Suivi commande Résumer Petit avoir Gros avoir PLUS D'AUTONOMIE Autonome exceptions seules Encadré agit, rend compte Réversible demande pour le reste Brouillon l'humain édite Suggérer l'humain agit avoir sous le plafond : automatique au-delà : attend une signature humaine avoir < 50 : automatique avoir >= 50 : validation Ce qui fait bouger le curseur réversibilité · vérifiabilité historique fiable
Fig. 4 · L'autonomie est un curseur. Autonomie réglée par action, de la suggestion à l'autonomie complète, avec des avoirs filtrés par montant.
Chapitre 5 · Partie I

Quand ne pas construire d'agent

La décision d'architecture la plus précieuse de ce livre est celle qui supprime entièrement l'agent. Cela sonne comme une hérésie dans un guide intitulé Agents en production, mais tous les praticiens expérimentés ont la même histoire : une équipe a passé un trimestre à construire un système autonome pour un problème qu'une fonction bien écrite et un seul appel de modèle auraient résolu en une semaine.

Les agents coûtent cher dans toutes les monnaies qui comptent. Chaque étape est un appel au modèle, si bien qu'ils coûtent plus et prennent plus de temps qu'un pipeline fixe. Ils sont non déterministes, donc plus difficiles à tester. Ils choisissent leur propre chemin, donc ils sont plus difficiles à expliquer, à auditer et à déboguer. Ils ont besoin de garde-fous, de budgets, de traçage et d'une infrastructure d'évaluation dont un système plus simple se passerait. Ces coûts valent la peine d'être payés quand le problème l'exige vraiment. Ils sont de la pure surcharge quand ce n'est pas le cas.

Alors demandez-vous, avant de construire : ce problème exige-t-il que le modèle décide de la suite ? Si les étapes sont connues à l'avance, il vous faut un workflow, où le code décide du chemin et où les modèles gèrent les parties floues à l'intérieur de chaque étape. S'il n'y a qu'une seule partie floue, il vous faut un seul appel de modèle bien conçu avec une sortie structurée. S'il n'y a aucune partie floue, il vous faut du logiciel ordinaire, et vous devriez vous en réjouir. Classification, extraction, résumé d'un document connu, routage d'un ticket vers l'une de six files : rien de tout cela n'a besoin d'une boucle.

Le meilleur agent est parfois une fonction bien élevée.

Les agents méritent leur place quand le chemin est véritablement ouvert. La recherche à travers des sources dont on ne peut prévoir ni le nombre ni la forme. Le débogage, où chaque observation change ce qu'il faut essayer ensuite. Les conversations clients qui vagabondent. Les opérations en plusieurs étapes sur des systèmes dont il faut inspecter l'état avant d'agir. Dans ces cas, écrire chaque branche à la main serait impossible ou absurde, et laisser un modèle choisir est la solution honnête.

Il existe aussi une option intermédiaire que les équipes négligent : construire d'abord le workflow, et laisser l'agent en émerger. Commencez par des étapes fixes. Observez où les vraies entrées imposent des embranchements maladroits, où le code se remplit de cas particuliers, où le chemin fixe se trompe sans cesse. Ce sont les endroits qui réclament le jugement d'un modèle. Déléguez la décision là, et seulement là. Vous obtenez un système en grande partie prévisible, avec du jugement appliqué là où il rapporte, ce qui est exactement la forme qui survit au contact des équipes d'exploitation.

Essayez cette semaine. Prenez la conception actuelle de votre agent et, pour chaque étape, demandez-vous si un expert humain aurait besoin de réfléchir à la suite ou se contenterait de suivre la procédure. Partout où la réponse honnête est « suivre la procédure », écrivez la procédure en code. Vous perdrez un peu d'élégance au tableau blanc et gagnerez beaucoup de sommeil. La question n'est jamais de savoir si les agents sont impressionnants. C'est de savoir si ce problème avait besoin d'être impressionné.

Vous faut-il vraiment un agent ? Chemin ouvert ? le modèle doit choisir ? Agent recherche, débogage, chats Une part floue ? jugement dans une étape oui non Code ordinaire et tant mieux aucune Un appel au modèle sortie structurée une Workflow le code fixe le chemin plusieurs faites-le grandir là où les cas abondent coûts d'un agent : un appel modèle par étape, non-déterminisme, garde-fous, budgets, traçage Le meilleur agent est parfois une fonction bien élevée.
Fig. 5 · Quand ne pas construire d'agent. Un arbre de décision pour choisir entre code ordinaire, un seul appel, un workflow ou un agent.
Chapitre 6 · Partie I

Définir « terminé »

Un agent sans définition de « terminé » tourne jusqu'à ce qu'il s'ennuie, soit ruiné ou se trompe, et il ne s'ennuie jamais. C'est l'un des plus vieux échecs du domaine et toujours l'un des plus courants : la boucle a une condition de départ et, à la place de la condition d'arrêt, un vague espoir.

Le modèle vous dira, bien sûr, quand il pense avoir fini. C'est un signal utile et une piètre garantie. Les modèles ont tendance à proclamer leur succès, surtout vers la fin d'une longue tâche, quand le contexte est encombré et les preuves minces. Ils annonceront que les tests passent alors qu'ils n'en ont lancé qu'une partie, que l'enregistrement a été mis à jour alors que l'appel a renvoyé une erreur qu'ils ont survolée, que la recherche est complète alors qu'ils ont trouvé deux sources et cessé de chercher. Rien de tout cela n'est malveillant. C'est ce qu'on obtient quand on demande à un système optimisé pour produire des complétions plausibles s'il a complété quelque chose.

Alors écrivez noir sur blanc ce que « terminé » veut dire, sous une forme que le harnais peut vérifier sans demander l'avis du modèle. Pour un agent de code, terminé peut signifier que la suite de tests passe, lancée par le harnais et non rapportée par le modèle. Pour un agent de saisie, terminé peut signifier que l'enregistrement cible existe avec chaque champ obligatoire rempli et valide. Pour un agent de recherche, terminé peut signifier un rapport dans une structure définie, avec au moins un nombre donné de sources citées, chacune accessible. Pour un agent de support, terminé peut signifier que le ticket est dans l'un d'un petit ensemble d'états finaux, chacun assorti d'un code motif.

Si seul l'agent peut vous dire qu'il a fini, vous n'avez pas défini « fini ».

« Terminé » a aussi une forme négative, qui compte tout autant. Définissez les conditions dans lesquelles l'agent doit s'arrêter sans avoir réussi : une limite d'étapes, une limite de temps, une limite de dépense, un échec répété, une demande qu'il n'a pas le droit de traiter. Ces arrêts doivent produire une issue honnête, du genre impossible à terminer, escaladé, voici ce que j'ai tenté, plutôt qu'un délai dépassé silencieux ou une invention enjouée. Un agent qui échoue clairement est bien plus utile qu'un agent qui réussit de façon ambiguë.

Deux habitudes pratiques aident. D'abord, faites produire à l'agent une sortie finale structurée, pas de la prose, pour que le harnais puisse la valider comme il validerait n'importe quelle réponse d'API. Ensuite, ajoutez une étape de vérification après que le modèle a revendiqué la fin, exécutée par du code ou par un correcteur distinct, avant que le résultat ne soit accepté. Cela coûte un peu de latence et épargne beaucoup d'embarras.

Cette semaine, ouvrez la boucle de votre agent et trouvez la ligne qui la termine. Si la seule sortie est le modèle qui dit j'ai fini, ajoutez un contrôle qui ne dépend pas de son autoévaluation, et ajoutez au moins deux façons dont l'exécution peut se terminer par un échec propre et étiqueté. Vous aurez l'impression d'être dur avec le modèle. Vous êtes gentil avec la personne qui lira le résultat. La ligne d'arrivée vous appartient, pas au coureur.

Le harnais vérifie la fin, le modèle ne fait que l'annoncer En cours tours de boucle Annonce la fin le modèle le dit Contrôle harnais code ou évaluateur Accepté sortie valide échec du contrôle : on continue Échec étiqueté escaladé + ce que j'ai tenté limite d'étapes · de temps limite de coût · échec répété requête non autorisée Fin, écrite Code tests verts, lancés par le harnais Saisie l'enregistrement existe, champs valides Recherche N sources citées qui résolvent Support état final + code motif Si seul l'agent peut dire qu'il a fini, vous n'avez pas défini « fini ».
Fig. 6 · Définir « terminé ». Une exécution finit quand le harnais vérifie la fin, ou par un échec propre et étiqueté.
Chapitre 7 · Partie I

Le non-déterminisme, c'est la météo

Lancez deux fois le même agent sur la même entrée et vous obtiendrez peut-être deux voyages différents. Une exécution cherche d'abord puis lit ; l'autre lit d'abord et ne cherche jamais. L'une finit en quatre étapes, l'autre en onze. Les deux peuvent être correctes, ou l'une peut être fausse. Ce n'est pas un bug à corriger. C'est la météo, et l'ingénierie de production consiste à construire des maisons que la pluie laisse indifférentes.

La variabilité vient de plusieurs endroits à la fois. L'échantillonnage introduit de l'aléa, même si le réduire aide moins qu'on ne l'espère, car de petites différences de contexte poussent quand même le modèle sur des chemins différents. Les résultats des outils varient d'un instant à l'autre : une recherche renvoie de nouvelles pages, une base de données a de nouvelles lignes, une API est lente. Et comme chaque étape dépend de la précédente, les petites différences s'additionnent. À l'étape huit, deux exécutions parties à l'identique peuvent se trouver dans des codes postaux différents.

La première conséquence est qu'une seule exécution réussie ne vous apprend presque rien. Il vous faut la distribution : à quelle fréquence l'agent réussit sur ce type d'entrée, à quelle fréquence il prend le chemin des écoliers, à quelle fréquence il échoue franchement, et à quel point. Cela signifie lancer les cas de nombreuses fois et rapporter des taux plutôt que des anecdotes. Un test qui est passé une fois est une rumeur. Un test qui est passé quatre-vingt-quatorze fois sur cent est une information.

Ne demandez pas si ça marche. Demandez à quelle fréquence, et ce qui se passe le reste du temps.

La deuxième conséquence touche à la conception. Si vous ne pouvez pas faire suivre le même chemin à chaque exécution, rendez chaque chemin sûr. Contraignez les outils pour qu'aucune séquence d'appels ne puisse faire quelque chose d'inacceptable. Validez les sorties pour que les mauvaises réponses soient rattrapées quelle que soit la façon dont elles ont été produites. Mettez du code déterministe autour des parties qui doivent l'être : calculs, argent, permissions, formatage pour les systèmes en aval. Laissez le modèle être créatif seulement là où la créativité est bienvenue, et clôturez-le de code partout ailleurs.

La troisième conséquence est culturelle. Les équipes qui découvrent les agents réagissent souvent à une exécution étrange en retouchant le prompt jusqu'à ce que l'étrangeté cesse. Elle cesse, sur cette entrée, pour l'instant. Ailleurs, une nouvelle étrangeté apparaît. Ce jeu de la taupe est épuisant et antiscientifique. L'alternative disciplinée consiste à rassembler les exécutions étranges dans un jeu, à mesurer le taux d'échec sur l'ensemble, à faire un changement, puis à mesurer à nouveau. C'est plus lent par changement et bien plus rapide par mois.

Alors cette semaine, choisissez une entrée importante et lancez votre agent dessus vingt fois. Lisez les traces côte à côte. Notez combien de chemins distincts il a pris et combien ont abouti à la bonne réponse. La plupart des équipes qui font l'exercice sont surprises, parfois agréablement, parfois non. Dans tous les cas, elles cessent de débattre pour savoir si l'agent fonctionne et commencent à mesurer à quel point. Vous ne pouvez pas arrêter la météo. Vous pouvez cesser d'être surpris par elle.

Même entrée, parcours différents Même entrée lancé 20 fois Chercher d'abord Lire d'abord 4 étapes correct 11 étapes correct 6 étapes mauvaise réponse Ne cherche jamais mauvaise réponse Tout chemin sûr Outils étroits Contrôle sorties Code pour l'argent Code pour l'accès Réussi une fois une rumeur Réussi 94 sur 100 une information Quelle fréquence ?
Fig. 7 · Le non-déterminisme, c'est la météo. Une même entrée prend de nombreux chemins ; rendez chacun sûr et comptez les taux de réussite.
Chapitre 8 · Partie I

Le harnais est le produit

Quand un système d'agent est bon, on félicite le modèle. Quand il est mauvais, on accuse le modèle. Dans les deux cas, on a généralement tort. En production, la qualité d'un agent est surtout la qualité de son harnais : le code qui assemble le contexte, définit les outils, exécute les appels, impose les limites, gère les erreurs, enregistre les traces et décide quand l'exécution est terminée.

Prenez deux équipes qui ont accès exactement au même modèle. La première lui donne quinze outils vaguement décrits, déverse une base de connaissances entière dans chaque prompt, exécute tout ce qu'il demande et accepte sa réponse finale telle quelle. La seconde lui donne cinq outils soigneusement conçus avec des descriptions claires, récupère le contexte à la demande, valide chaque appel, relance les échecs transitoires, plafonne les dépenses et contrôle la sortie finale à l'aide d'un schéma et d'un correcteur. La seconde équipe aura un système plusieurs fois plus fiable, et ses collègues supposeront qu'elle a trouvé un meilleur modèle.

C'est une bonne nouvelle, parce que le harnais est la partie que vous pouvez réellement améliorer. Les mises à jour de modèle arrivent au calendrier d'un fournisseur, modifient plusieurs comportements à la fois et cassent parfois des choses sur lesquelles vous comptiez. Les améliorations du harnais arrivent au vôtre. Une meilleure description d'outil part le mardi. Une politique de relance part le mercredi. Une nouvelle règle de validation part le jeudi, avec un test prouvant qu'elle rattrape l'échec observé le lundi. Chaque changement est petit, testable et réversible, ce qui est la forme de tout bon progrès d'ingénierie.

Choisissez le modèle avec soin. Puis passez le reste de votre temps sur tout le reste.

Cela change aussi la façon de composer l'équipe. Construire un agent de production n'est pas d'abord un travail de rédaction de prompts, même si les prompts comptent. C'est un travail d'ingénierie backend avec, au milieu, un composant aux opinions inhabituellement arrêtées. Les compétences qui comptent sont la conception d'API, les systèmes distribués, l'observabilité, les tests et la sécurité, les mêmes qui rendent n'importe quel service fiable, appliquées avec une compréhension du comportement des modèles. Les équipes qui ne recrutent que pour l'art du prompt ont tendance à produire des systèmes charmants qui s'effondrent sous la charge.

Un bon harnais survit aussi à son modèle. Quand un nouveau modèle arrive, un harnais bien construit vous permet de le brancher, de lancer la suite d'évaluation, de comparer traces et coûts, et de décider sur pièces. Un harnais mal construit porte les manies de l'ancien modèle tissées en lui sous forme de contournements dans les prompts et de cas particuliers, et la migration devient un chantier d'archéologie. Gardez les accommodements propres à un modèle petits, nommés et documentés, pour pouvoir les retrouver plus tard.

Cette semaine, dessinez votre harnais sous forme de schéma : chaque étape qu'une requête traverse entre son arrivée et la production d'un résultat. Marquez celles qui ont des tests, celles qui émettent des traces, et celles qui peuvent échouer sans que personne ne le remarque. La plupart des équipes découvrent que l'appel au modèle est la partie la mieux instrumentée du système et l'exécution des outils la moins bien. C'est le monde à l'envers. Le modèle est l'invité brillant. Le harnais est la maison, et c'est la maison qui doit tenir debout.

Où va vraiment une requête INSTRUMENTATION TYPIQUE Arrivée requête file, user, planning Montage contexte récupéré à la demande Définitions d'outils cinq claires, pas quinze floues Appel au modèle la partie louée Validation d'appel schéma, permission Exécution d'outil timeouts, relances Limites étapes, coût, temps Contrôle sortie schéma plus évaluateur le mieux mesuré : l'appel modèle le moins mesuré : l'exécution Le modèle est l'invité brillant. Le harnais est la maison.
Fig. 8 · Le harnais est le produit. Les étapes que traverse une requête, et l'inégalité de leur instrumentation.
Chapitre 9 · Partie I

Le lundi matin est un test

Le sous-titre de ce livre est une plaisanterie au tranchant sérieux. Le lundi matin, c'est le moment où les systèmes de production rencontrent le monde sous son jour le moins indulgent. L'arriéré du week-end arrive d'un coup. Les services en aval redémarrent après maintenance. Les utilisateurs sont fatigués, laconiques et pressés. L'ingénieur qui connaît le mieux l'agent est en réunion. Si votre système survit au lundi matin, il survivra probablement au reste de la semaine.

Pensez à ce que contient réellement cette matinée. Le volume d'abord : les requêtes arrivent en rafale, et votre agent, qui en traitait volontiers une à la fois pendant les tests, partage désormais ses quotas avec quatre cents collègues. Puis les entrées bizarres : le client qui a collé un fil d'e-mails entier, la demande dans une langue que vous n'avez pas testée, la pièce jointe qui est la photo d'un écran. Puis l'état périmé : le cache qui était juste vendredi, l'enregistrement qu'un autre système a modifié pendant la nuit. Puis les pannes partielles : le service de recherche est lent, le CRM renvoie des erreurs pour une région, une API tierce a changé le nom d'un champ sans prévenir personne.

Rien de tout cela n'est exotique. C'est l'exploitation ordinaire, et le logiciel ordinaire a appris à la gérer au fil des décennies. Le problème avec les agents, c'est qu'ils la gèrent de façons nouvelles et parfois créatives. Un service classique qui tombe sur un enregistrement mal formé lève une erreur et s'arrête. Un agent peut décider de contourner le problème, en inventant une valeur plausible, en essayant un autre outil, ou en donnant au client une réponse assurée bâtie sur une recherche vide. La créativité qui rendait la démo impressionnante devient ce qu'il vous faut le plus contenir.

Le logiciel échoue bruyamment. Les agents peuvent échouer poliment, ce qui est pire.

Alors testez délibérément le lundi. Avant le lancement, faites tourner votre agent sur une rediffusion d'une vraie période chargée, ou sur une période synthétique au volume et au désordre réalistes. Injectez des pannes dans ses outils : délais dépassés, erreurs, résultats vides, déchets. Regardez ce qu'il fait. Vous voulez le voir relancer avec bon sens, rendre compte honnêtement et escalader quand il ne peut pas continuer. Vous ne voulez pas le voir improviser. Chaque improvisation trouvée en test est une de moins à trouver en revue d'incident.

Prévoyez aussi l'absence de l'expert. Écrivez le runbook qui explique à quelqu'un d'autre comment voir ce que fait l'agent, comment le ralentir, comment l'arrêter, et comment savoir si une sortie étrange est un cas isolé ou une tendance. Si ce runbook n'existe pas, l'agent n'est pas prêt, aussi bon que soit son taux de réussite. Être prêt pour la production inclut la capacité d'un inconnu à exploiter le système à un mauvais moment.

Cette semaine, programmez une heure de ce que certaines équipes appellent un game day. Choisissez une dépendance, faites-la tomber dans un environnement de test et observez votre agent pendant ce temps. Puis faites de même avec une rafale d'entrées tordues. Notez ce qui vous a surpris et corrigez le pire. Le lundi revient chaque semaine. Autant l'accueillir à vos conditions.

Ce que contient le lundi matin Lundi 09:00 Pics de volume quotas partagés Entrées bizarres fils collés, photos État périmé cache de vendredi Pannes partielles recherche lente, champ renommé Expert absent runbook pour un inconnu Le logiciel échoue bruyamment. Les agents échouent poliment. Voulu : relancer, signaler, escalader Pas voulu : improviser
Fig. 9 · Le lundi matin est un test. Les cinq pressions du lundi matin, et la réponse attendue d'un agent.
Chapitre 10 · Partie I

La fiabilité est un métier d'ingénieur

Voici l'argument de ce livre en miniature, pour que vous puissiez décider tôt si vous y adhérez. Le prompt façonne ce qu'un agent a tendance à faire. L'ingénierie détermine ce qu'il peut faire, ce qui se passe quand il se trompe, et comment vous l'apprenez. La fiabilité en production relève presque entièrement de la seconde catégorie.

Ce n'est pas un rejet du prompt. Un prompt système clair, de bonnes descriptions d'outils et des exemples bien choisis font une énorme différence sur la fréquence à laquelle un agent fait ce qu'il faut, et les chapitres suivants les traitent avec respect. Mais un prompt est une demande, pas une garantie. Il déplace des probabilités. Il ne peut pas rendre une action dangereuse impossible, un état perdu récupérable, un coût borné ou un incident visible. Ces propriétés viennent du code, de la configuration et des processus, et elles tiennent que le modèle soit dans un bon jour ou non.

Regardez les échecs qui font vraiment mal aux équipes. Un agent a envoyé onze fois le même e-mail à un client parce qu'une relance n'était pas idempotente. Un agent a laissé fuiter un document parce qu'il avait lu une instruction cachée dans une page web et disposait d'un outil capable d'envoyer des messages n'importe où. Un agent a tourné en boucle toute la nuit et consommé le budget d'un mois. La qualité d'un agent a lentement décliné après le changement d'une dépendance, et personne ne l'a remarqué pendant six semaines parce que rien ne la mesurait. Aucun de ces problèmes ne se règle avec un meilleur prompt. Chacun se règle par une pratique d'ingénierie ordinaire appliquée à un composant inhabituel.

On ne remplace pas un garde-fou manquant par une consigne.

Ces pratiques ne sont pas nouvelles. Moindre privilège. Idempotence. Délais d'expiration et relances avec temporisation. État durable. Validation des entrées. Budgets et quotas. Traçage structuré. Tests de non-régression. Déploiements progressifs. Boutons d'arrêt d'urgence. Post-mortems sans recherche de coupable. Ce qui est nouveau, c'est de les appliquer à un composant qui prend des décisions, ce qui change certains détails et aucun des principes. Le reste de ce livre est une visite guidée de ces pratiques, chacune traduite pour les agents.

Il vaut la peine de nommer la raison pour laquelle les équipes résistent. Le prompt est rapide et donne l'impression d'avancer. On change une phrase, on relance la démo, on voit une meilleure réponse, on livre. L'ingénierie est plus lente et ses victoires sont invisibles : l'incident qui n'a pas eu lieu, le coût resté stable, la régression rattrapée avant la sortie. Les organisations récompensent le visible. Votre travail consiste en partie à rendre visible l'invisible, avec des tableaux de bord, des scores d'évaluation et des décomptes d'incidents, pour que le travail discret reçoive le crédit qu'il mérite.

Voici donc le premier test de votre système. Pour chaque préjudice grave que votre agent pourrait causer, demandez-vous ce qui l'empêche. Si la réponse est une phrase dans le prompt, notez quel code, quelle permission ou quel processus pourrait l'empêcher à la place, et mettez ce travail sur la liste. Vous ne finirez pas la liste cette semaine. Vous aurez en revanche converti un espoir en backlog, ce qui est le point de départ de tout système fiable. La fiabilité n'est pas une humeur du modèle. C'est une propriété que vous construisez.

Incidents qu'un meilleur prompt n'aurait pas réglés INCIDENT PROMPT Correctif tech. E-mail envoyé 11 fois relance non idempotente non Clés d'idempotence relances sans risque Document divulgué instruction cachée, outil d'envoi non Moindre privilège envoi sur liste blanche Budget du mois épuisé boucle nocturne non Budgets et plafonds le coût stoppe l'exécution Lent déclin de six semaines rien ne le mesurait non Évals continues scores sur un tableau de bord LES VIEILLES PRATIQUES, APPLIQUÉES À UN COMPOSANT QUI DÉCIDE moindre privilège idempotence timeouts état durable validation budgets traçage tests de régression déploiement gradué coupe-circuit postmortems Aucune consigne ne remplace un garde-fou manquant.
Fig. 10 · La fiabilité est un métier d'ingénieur. Quatre incidents réels qu'un prompt n'aurait pas réglés, chacun associé à un correctif d'ingénierie.
Extrait gratuit · Partie I

Continuer la lecture

Vous avez lu les 10 premiers chapitres sur 100 de Agents en production. Le livre complet contient chaque chapitre et chaque planche, en PDF et EPUB, en anglais, français, polonais et espagnol.

Le livre complet arrive bientôt dans la boutique.

Déjà acheté ? Lire l’édition complète en ligne

Agents en production · Première édition, octobre 2026
100 chapitres · 10 parties · cent schémas
par Mat Siems · MS Books, No. 11 · 2026