Anti-patterns agentiques
Ce qu'il ne faut pas construire. Chaque fiche décrit un choix d'architecture qui se paie en production : les symptômes qui le trahissent, pourquoi il nuit, les incidents publics qu'il a causés et les patterns du catalogue qui y remédient.
Cadrage et choix du niveau
Ai-je choisi le bon niveau d’architecture ?
Construire plus compliqué que nécessaire, ou viser une autonomie que rien ne justifie : les erreurs commises avant la première ligne de code.
- AP01 · Agent là où un workflow suffit — Le chemin est connu d’avance, mais un modèle le redécide à chaque exécution.
- AP02 · Multi-agent par défaut — Plusieurs agents découpés par rôles, là où un agent seul réussissait déjà la tâche.
- AP03 · LLM pour une décision déterministe — Le modèle tranche ce qu’une règle, un parseur ou un linter ferait exactement et presque gratuitement.
- AP04 · Effort non proportionné à la tâche — Une question factuelle mobilise la même machinerie qu’une recherche approfondie.
- AP05 · Un seul modèle pour tout — Le même modèle sert toutes les étapes, du reformatage trivial au raisonnement difficile.
- AP06 · Tâche plus longue que l’horizon fiable — Une tâche de plusieurs heures confiée d’un bloc, que l’agent tente de produire d’une traite.
- AP07 · Solution en quête de problème — Le projet part de ce que le modèle sait faire, et non d’un résultat métier mesurable.
- AP08 · Autonomie totale sur la foi d’une démo — Une démonstration réussie suffit à lancer l’agent en exécution autonome, sans palier intermédiaire.
- AP09 · « Agent washing » — Un chatbot, un assistant ou une RPA rebaptisés « agent », pour l’acheter ou pour le vendre.
Outils et interface agent-machine
Mes outils sont-ils conçus pour un agent ?
Des outils pensés pour des développeurs, trop nombreux, trop bavards ou trop puissants.
- AP10 · Outil calqué sur l’API — Chaque point d’accès d’une API pour développeurs devient un outil, sans regroupement par tâche.
- AP11 · MCP par défaut — MCP est choisi par réflexe, là où une CLI documentée ou un appel direct suffisait.
- AP12 · Trop d’outils chargés d’emblée — Toutes les définitions d’outils sont chargées à chaque tour, y compris celles qui se recoupent.
- AP13 · Sorties d’outils non bornées — Le résultat brut d’un outil entre tel quel dans le contexte, quelle que soit sa taille.
- AP14 · Résultats intermédiaires qui transitent par le contexte — Une grosse donnée traverse le contexte du modèle à seule fin d’être recopiée vers un autre outil.
- AP15 · Erreur d’outil non actionnable — L’outil en échec renvoie un code ou une pile d’appels, et rien sur ce qu’il faut corriger.
- AP16 · Outil piège — Les paramètres de l’outil rendent l’erreur facile : nom ambigu, chemin relatif, argument déjà connu.
- AP17 · Format de sortie hostile au modèle — Le modèle dépense son effort à échapper du JSON ou à compter des lignes, au lieu de faire la tâche.
- AP18 · Sur-outillage spécialisé — Une dizaine d’outils sur mesure, là où un accès générique à une documentation propre suffisait.
- AP19 · Outil à fonctionnalité excessive — Un outil ouvert (SQL brut, shell, HTTP libre) là où la tâche n’exige que quelques actions bornées.
- AP20 · Texte vers SQL sans couche sémantique — Le modèle traduit la question en SQL exécuté directement sur la base, sans définitions métier ni revue.
Instructions
Mes consignes sont-elles lisibles et à jour ?
Des prompts qui grossissent, se contredisent ou compensent un modèle qui n’est plus là.
- AP21 · Instructions obèses — Un fichier d’instructions qui grossit à chaque incident, jusqu’à ce que des règles importantes soient ignorées.
- AP22 · Prompt contradictoire — Deux consignes incompatibles dans le même prompt, et le modèle dépense son raisonnement à les concilier au lieu d’agir.
- AP23 · Logique métier codée en dur dans le prompt — Un arbre de « si… alors » écrit en prose, qu’un modèle probabiliste exécute mal et qui grossit à chaque bogue.
- AP24 · Sur-insistance héritée d’un ancien modèle — Des “CRITICAL: You MUST” (il le faut absolument) écrits pour l’ancien modèle, que le nouveau prend au pied de la lettre.
Contexte et mémoire
Que lit l’agent, et que retient-il ?
Un contexte qui gonfle, s’empoisonne ou casse le cache ; une mémoire que n’importe quel contenu peut écrire.
- AP25 · Contexte qui gonfle sans gestion — Tout s’accumule dans la fenêtre, et l’agent exploite de moins en moins bien ce qu’il a sous les yeux.
- AP26 · Empoisonnement du contexte — Une erreur écrite dans le contexte devient un fait, que l’agent relit et renforce à chaque tour.
- AP27 · Consigne éparpillée au fil des tours — La demande arrive par morceaux ; l’agent s’engage dès le premier et ne revient plus en arrière.
- AP28 · Erreurs gardées brutes, ou effacées — Chaque tentative ratée reste mot pour mot dans l’historique et en appelle d’autres, ou elle disparaît avec sa leçon.
- AP29 · Compaction destructive — Un résumé qui efface l’original : le jour où un détail compte, plus rien ne permet de le retrouver.
- AP30 · Préfixe instable qui casse le cache — Un horodatage ou un JSON réordonné en tête du prompt, et chaque appel repaie tout le contexte au prix fort.
- AP31 · Contexte uniforme qui piège l’agent — Vingt CV traités à la suite dans le même contexte, et l’agent finit par imiter ses propres décisions.
- AP32 · Contexte mal transmis entre agents — Un résumé qui perd l’essentiel, ou un historique brut où le sous-agent s’attribue les actions d’un autre.
- AP33 · Mémoire en écriture libre — L’agent retient ce qu’il lit, y compris les ordres glissés dans un document, et les relit plus tard comme des faits.
- AP34 · RAG vectoriel par réflexe pour du code — Une base vectorielle pour retrouver du code, là où `grep` et la lecture de fichiers font mieux et plus simplement.
Boucle, arrêt et orchestration
Qui décide de s’arrêter, et qui vérifie ?
Des boucles sans borne, des fins déclarées sans preuve, des erreurs qui passent d’un agent à l’autre.
- AP35 · Boucle sans borne ni budget — Rien dans le code n’arrête l’agent : ni plafond de tours, ni budget, ni délai.
- AP36 · Fin décidée par l’agent seul — L’agent dit « terminé », et personne ne vérifie l’état réel avant de le croire.
- AP37 · Agir sans vérifier l’effet — Une action échoue en silence, et l’agent enchaîne comme si elle avait réussi.
- AP38 · Délégation sans brief — Une sous-tâche confiée en quelques mots : ce qui n’est pas écrit dans le brief n’existe pas pour le sous-agent.
- AP39 · Propagation sans validation — La sortie d’un agent devient l’entrée du suivant sans contrôle, et une erreur locale finit dans le livrable.
- AP40 · Plusieurs agents qui écrivent en parallèle — Plusieurs agents modifient le même livrable en même temps, chacun avec ses propres décisions implicites.
- AP41 · Débat qui converge vers l’erreur — Des agents débattent pour se corriger et finissent alignés sur la réponse la plus assurée, même fausse.
- AP42 · Multi-agent sans attribution ni provenance — Le livrable est faux, et personne ne peut dire quel agent a introduit l’erreur, ni à quelle étape.
- AP43 · Agent sans durabilité ni idempotence — Une panne à mi-parcours, et l’agent repart de zéro en renvoyant le courriel qu’il avait déjà envoyé.
- AP44 · Déploiement qui coupe les agents en cours — Une nouvelle version remplace l’ancienne d’un coup, en plein milieu des sessions d’agents qui s’appuyaient sur elle.
- AP45 · Latence cumulée des sauts — Des appels LLM enchaînés en série, sans budget de latence : la réponse arrive après la somme de toutes les étapes.
Vérification et évaluation
Comment sais-je que ça marche ?
Pas d’évaluation, un évaluateur complaisant, ou un oracle que l’agent peut modifier.
- AP46 · Pas d’évaluation, seulement des correctifs — Chaque plainte donne lieu à un correctif, et personne ne sait si l’agent progresse ou régresse.
- AP47 · Évaluateurs écrits pour des erreurs imaginées — On mesure « l’utilité » ou « l’hallucination » avant d’avoir lu une seule trace : le tableau de bord est vert, les utilisateurs non.
- AP48 · Juge LLM non validé — Un LLM note les sorties, et personne n’a vérifié qu’il note comme un expert humain.
- AP49 · L’agent juge son propre travail — Le même agent produit et note : il trouve presque toujours son travail bon.
- AP50 · Oracle visible et modifiable par l’agent — L’agent voit ou peut réécrire ce qui le note, et finit par optimiser la note plutôt que la tâche.
- AP51 · Tests verts comme seul critère de fin — La batterie de tests passe, donc c’est fini : sauf que la revue refuse la PR.
- AP52 · Fiabilité mesurée sur un seul essai — Réussir un essai prouve que l’agent sait faire, pas qu’il réussira à chaque fois.
- AP53 · Tâche d’évaluation cassée, correcteur rigide — Le score mesure le correcteur, pas l’agent : un arrondi suffit à transformer une bonne réponse en échec.
- AP54 · Essais d’évaluation non isolés — Les essais partagent le même dépôt : le suivant profite des traces du précédent.
- AP55 · Comparer des architectures sans budget égal — Le multi-agent « gagne », avec dix fois plus de tokens que l’agent seul auquel on le compare.
- AP56 · Livrer sans oracle de vérification — Les références ont l’air vraies et les tests sont « réussis » : personne n’a vérifié ni les unes ni les autres.
- AP57 · Piloter par une métrique de vanité — Les pouces levés montent, les recontacts aussi : la métrique s’améliore pendant que le résultat se dégrade.
Sécurité et droits
Que peut faire une entrée hostile ?
Une règle de sécurité laissée au prompt, des droits trop larges, une production à portée de l’agent.
- AP58 · Garde-fou probabiliste comme unique barrière — Un filtre ou un classifieur d’injection fait office de frontière, sans aucune contrainte d’architecture derrière.
- AP59 · Trifecta létale en autonomie — Un même agent lit du contenu non fiable, touche aux données privées et peut émettre, sans que personne n’approuve.
- AP60 · Canal de sortie par rendu non contrôlé — L’interface charge d’elle-même les images dont le modèle écrit l’URL : un canal d’émission que personne n’a conçu.
- AP61 · Le contenu d’un tiers agit avec les droits du mandant — L’agent agit avec les droits de qui le lance, sur un texte écrit par un tiers moins privilégié.
- AP62 · Identité et jetons trop larges — L’agent agit sous une identité commune et puissante, avec des jetons qui couvrent bien plus que sa tâche.
- AP63 · Consigne de sécurité confiée au prompt — La règle « ne touche pas à la production » n’existe que dans le prompt ; rien ne l’impose à l’appel d’outil.
- AP64 · Environnements non séparés — L’agent de développement atteint la production, et les sauvegardes partagent son rayon d’impact.
- AP65 · Agent qui modifie sa propre configuration — L’agent peut écrire dans les fichiers qui fixent ses permissions : une injection ne contourne plus l’approbation, elle la désactive.
- AP66 · Confirmations désactivées hors d’un bac à sable — L’agent tourne sans aucune confirmation sur un poste qui contient des secrets et garde un accès réseau ouvert.
- AP67 · Chaîne d’approvisionnement d’outils non vérifiée — Serveurs MCP, extensions et skills installés sans vérification ni épinglage, avec toute la confiance de l’agent.
- AP68 · Secrets à portée de l’agent — Les identifiants sont lisibles par l’agent, dans son contexte ou dans ses fichiers, au lieu d’être injectés hors du modèle.
- AP69 · Confiance implicite entre agents — Les agents se découvrent et se délèguent des tâches par défaut : un agent modeste peut recruter le plus puissant.
- AP70 · Agent qui navigue dans la session authentifiée de l’utilisateur — Un navigateur agentique lit n’importe quelle page avec les sessions ouvertes de la messagerie et de la banque de l’utilisateur.
- AP71 · Objectif impératif et actions irréversibles sans supervision — Un objectif à atteindre coûte que coûte, des actions irréversibles, et personne pour les approuver.
Supervision, exploitation et gouvernance
Qui surveille, qui répond, qui arrête ?
Une validation humaine de façade, un agent opéré à l’aveugle, des régressions que personne ne voit.
- AP72 · Validation humaine de façade — L’humain approuve presque tout, en quelques secondes, sur des demandes qui ne montrent pas ce qui va se passer.
- AP73 · Retirer l’humain trop tôt — Les équipes humaines sont réduites sur les premiers chiffres de l’agent, et les cas complexes reviennent, plus tard et plus irrités.
- AP74 · Agent face au client sans responsable — L’agent répond au nom de l’entreprise, invente une règle, et l’entreprise découvre qu’elle est engagée par ce qu’il a dit.
- AP75 · Agent opéré à l’aveugle — En production sans trace par étape : on ne peut ni rejouer une session, ni dire où elle a échoué.
- AP76 · Le récit de l’agent tient lieu de journal d’audit — On sait ce que l’agent dit avoir fait, pas ce qu’il a fait : aucun journal indépendant ne permet d’enquêter.
- AP77 · Régressions silencieuses au changement — Le modèle, le prompt ou l’infrastructure change, et seuls les utilisateurs voient la qualité baisser.
- AP78 · Pas d’interrupteur ni de plafond de rayon d’impact — Impossible d’arrêter un agent précis en un geste, ou de limiter le nombre d’actions qu’il enchaîne.
- AP79 · Agents sans propriétaire ni inventaire — Des agents publiés, partagés ou oubliés, que personne ne surveille, ne plafonne ni ne peut révoquer.
- AP80 · Coût mesuré au mauvais niveau — La dépense est suivie par appel ou par agent principal ; sous-agents, reprises et échecs passent sous le radar.
- AP81 · Couplage dur à un fournisseur — L’agent repose sur une API à état ou un modèle précis, sans couche d’isolation : la migration forcée devient une refonte.
- AP82 · Framework opaque — Le framework cache le prompt, le contexte envoyé ou le flux de contrôle : on ne règle pas ce qu’on ne voit pas.
- AP83 · Composant de harnais devenu inutile — Un découpage, un outil ou une consigne compensait un ancien modèle ; il coûte toujours et n’apporte plus rien.
- AP84 · Harnais à sens unique — Des règles jamais vérifiées, ou des alertes qui ne changent jamais les règles : le harnais n’apprend pas.