Un agent IA qui fonctionne bien en démonstration impressionne par son autonomie : il lit, cherche, décide, agit. En production, c’est souvent l’inverse qui fait sa valeur : sa capacité à reconnaître qu’il ne doit pas agir seul. Un agent qui envoie un e-mail erroné à un client, accorde un geste commercial injustifié ou modifie la mauvaise fiche dans un CRM coûte plus cher que le temps qu’il a fait gagner.

« Humain dans la boucle » ne veut pas dire faire valider chaque action par une personne, ce qui annulerait l’intérêt de l’agent. Cela veut dire décider, dès la conception, à quels moments précis l’agent doit s’arrêter, demander, ou passer la main. Cet article présente les mécanismes que nous mettons en place pour y parvenir.

Toutes les actions ne se valent pas

La première étape consiste à classer les actions que l’agent peut effectuer selon leur impact. Une grille simple suffit souvent :

  • Lire et chercher : consulter une base documentaire, un historique, une fiche client. Risque faible, l’agent peut agir seul.
  • Préparer : rédiger un brouillon, pré-remplir un formulaire, proposer une réponse. L’agent produit, un humain décide de l’utiliser ou non.
  • Agir de façon réversible : créer une tâche, ajouter une note interne, classer un ticket. L’agent peut agir seul si l’action est tracée et facile à annuler.
  • Agir de façon irréversible ou visible : envoyer un message à un client, déclencher un paiement, supprimer une donnée, modifier un contrat. Validation humaine obligatoire.

Cette classification se fait avec les équipes métier, pas uniquement avec les équipes techniques. Ce sont elles qui savent quelles erreurs sont acceptables et lesquelles ne le sont pas.

Les points de validation

Pour les actions sensibles, l’agent ne s’arrête pas sur un simple « êtes-vous sûr ? ». Il présente à la personne qui valide tout ce dont elle a besoin pour décider vite et bien : l’action proposée, les informations sur lesquelles elle repose, les sources consultées, et ce qui se passera après validation. Une bonne demande de validation se traite en quelques secondes ; une mauvaise oblige à refaire tout le travail de l’agent.

Le format compte aussi : la validation doit arriver là où la personne travaille déjà, dans sa messagerie, son outil de ticketing ou son CRM, plutôt que dans une interface supplémentaire qu’elle finira par ignorer.

Un bon agent n’est pas celui qui fait tout seul. C’est celui qui sait exactement quand il ne doit pas le faire.

Savoir escalader

Au-delà des actions sensibles, un agent doit reconnaître les situations qui sortent de son périmètre et les transmettre à la bonne personne. Les déclencheurs d’escalade les plus utiles sont souvent simples :

  • la demande ne correspond à aucun cas prévu ;
  • les informations trouvées sont contradictoires ou incomplètes ;
  • le client exprime un mécontentement, une urgence ou une menace de départ ;
  • l’agent a déjà tenté plusieurs approches sans aboutir ;
  • un montant, un volume ou un enjeu dépasse un seuil défini.

Une escalade réussie transmet le contexte complet : ce que l’agent a compris, ce qu’il a déjà fait, et pourquoi il s’arrête. La personne qui reprend le dossier ne doit jamais avoir à tout recommencer.

Les seuils de confiance, utiles mais pas suffisants

Il est tentant de demander au modèle d’évaluer sa propre confiance et d’escalader en dessous d’un certain niveau. C’est utile, mais à manier avec prudence : un modèle peut être très confiant et se tromper. Les signaux les plus fiables sont souvent externes au modèle : la source a-t-elle été trouvée, les montants sont-ils cohérents, le client est-il connu, la règle métier est-elle respectée ?

Nous combinons donc les deux : des vérifications explicites par le code, et une auto-évaluation du modèle comme signal complémentaire. Les seuils sont réglés à partir de cas réels, puis ajustés à mesure que l’on observe le comportement de l’agent.

Tracer et pouvoir annuler

Chaque action de l’agent doit laisser une trace lisible : ce qu’il a fait, à partir de quelles informations, à quel moment, et qui a validé le cas échéant. Cette traçabilité sert à comprendre un incident, à améliorer l’agent, et à rendre des comptes si nécessaire.

Elle va de pair avec la capacité d’annuler. Quand c’est possible, nous concevons les actions de l’agent pour qu’elles soient réversibles : un brouillon plutôt qu’un envoi, un changement de statut plutôt qu’une suppression, une modification historisée plutôt qu’un écrasement. Un système dont on peut défaire les erreurs se déploie avec beaucoup plus de sérénité.

Ces garde-fous protègent aussi contre la prompt injection : même si un contenu piégé parvient à détourner l’agent, une action sensible ne peut pas aboutir sans qu’un humain l’ait vue.

Un exemple concret

Un agent de service client traite les demandes de remboursement d’un site e-commerce. Il consulte la commande, vérifie les conditions de retour et prépare une réponse. Dans une première version, il pouvait accorder lui-même tous les remboursements jugés conformes.

La version déployée distingue trois cas. Les remboursements standards, sous un montant défini et conformes aux conditions, sont accordés automatiquement et tracés. Les demandes hors conditions ou au-dessus du seuil arrivent chez un conseiller avec un dossier complet : historique du client, analyse de l’agent, réponse proposée. Les messages qui expriment une forte insatisfaction sont escaladés immédiatement, sans réponse automatique. Les conseillers ne traitent plus que les cas qui méritent leur attention, et chaque décision de l’agent peut être retrouvée et expliquée.

Notre recommandation

Commencez avec plus de validation humaine que nécessaire, puis relâchez progressivement. Les premières semaines servent à observer les décisions de l’agent, à identifier les cas qu’il traite de façon fiable et ceux où il hésite. Les seuils et les points de validation s’ajustent sur ces observations, pas sur des suppositions. Un agent qui gagne la confiance des équipes étape par étape finit par traiter beaucoup plus qu’un agent lancé en pleine autonomie et rapidement désactivé après sa première erreur visible.