Human-in-the-Loop
Aussi appelé : HITL, approval gate, interrupt, approbation d'outil, demande de permission, escalade vers un humain, humain comme outil, principe des quatre yeux
Intention
Arrêter un agent à quelques points choisis, sauvegarder tout son état, et laisser une personne approuver, modifier, rejeter ou répondre avant que le run continue. Le code décide où le run s'arrête, un humain décide de ce qui s'y passe, et le run reprend exactement là où il s'était mis en pause, avec cette décision injectée.
Problème
Vous faites tourner un agent de support client pour une boutique en ligne d'articles pour la maison. Il discute avec les clients et dispose d'outils pour consulter les commandes, effectuer des remboursements, rédiger et envoyer des e-mails, et modifier les adresses de livraison. Un client écrit : « La commande 981 est arrivée cassée, je veux récupérer mes 480 $. » La règle de la boutique dit que le support peut rembourser jusqu'à 250 $ ; au-delà, c'est la finance qui décide.
Laissé seul, l'agent lit la commande, constate un article endommagé et appelle issue_refund(order=981, amount=480). Chaque appel d'outil était valide. Il manquait simplement à l'agent un contexte qu'une personne avait. Là où ça casse :
- Effets de bord irréversibles. Une fois l'argent versé ou l'e-mail parti, un meilleur modèle à l'étape suivante ne peut plus rien défaire. Anthropic note que les erreurs d'agent s'accumulent, et donne l'exemple d'un agent de notes de frais qui résilie un abonnement dont l'équipe finance avait encore besoin.
- Des actions plausibles mais non voulues. L'article d'Anthropic sur le mode auto de Claude Code cite le comportement « trop zélé » (overeager) et les erreurs de bonne foi comme principaux risques : l'agent fait quelque chose de raisonnable que personne n'a demandé.
- Personne n'est responsable. Dans les secteurs réglementés, quelqu'un doit pouvoir corriger ou arrêter le système. L'article 14 de l'AI Act européen impose que les systèmes à haut risque permettent aux personnes chargées de la surveillance d'ignorer les sorties et d'arrêter le système avec un bouton d'arrêt ou une procédure équivalente.
- La solution évidente échoue aussi. Demander avant chaque appel habitue les gens à cliquer sur « oui ». Anthropic indique que les utilisateurs acceptent 93 % des demandes de permission manuelles de Claude Code. Un point de validation toujours approuvé ne protège presque pas.
Solution
Ajoutez trois éléments autour de la boucle de l'agent. Une politique, écrite en code, décide quelles actions proposées nécessitent un humain. Une pause durable sauvegarde tout le run et rend la main, si bien que rien n'a besoin de tourner pendant qu'une personne réfléchit. Une reprise recharge le run, applique la décision de la personne une seule fois et continue. Tout le reste ne change pas.
- L'agent propose. Le modèle émet
issue_refund(order=981, amount=480). Rien ne s'exécute encore. - La politique décide. Du code ordinaire, pas le modèle, examine l'appel : la consultation de commande est autorisée, les remboursements de plus de 50 $ nécessitent un humain (le responsable support jusqu'à 250 $, la finance au-delà), et la suppression de compte est refusée d'office. Ce remboursement fait 480 $, il part donc à la finance.
- Pause et sauvegarde. Le runtime construit une demande d'approbation (ce qui va se passer, pourquoi, impact : irréversible, 480 $), sauvegarde les messages et l'appel en attente sous l'identifiant de thread
ticket-981, puis rend la main. L'agent dit au client que le remboursement attend une approbation. - Notification et attente. La demande arrive dans le canal de la finance. Elle peut y rester des heures. Un minuteur tourne ; si personne ne décide à temps, le comportement par défaut est de ne pas rembourser et d'escalader.
- L'humain décide. Alice, à la finance, ramène le montant à 250 et ajoute un commentaire : « plafond de la politique, proposer un avoir pour le reste ».
- Reprise. L'application relance le run avec le même identifiant de thread et la décision d'Alice. Le runtime vérifie que la décision correspond à la demande enregistrée, vérifie que la commande n'a pas été remboursée entre-temps, exécute
issue_refund(order=981, amount=250)avec l'identifiant de la demande comme clé d'idempotence, et le modèle lit le commentaire puis propose un avoir. - Trace. La demande, la décision, son auteur, l'heure et ce qui a réellement été exécuté vont dans le journal d'audit.
Qui décide du déroulement : le pattern sous-jacent décide toujours du chemin (ici une boucle ReAct). Le code décide où le run s'arrête. L'humain décide seulement de ce qui se passe à cet arrêt. C'est pour cela que Human-in-the-Loop n'est pas une topologie comme un superviseur ou un swarm : vous l'ajoutez à n'importe laquelle d'entre elles.
Le voisin le plus proche est Evaluator–Optimizer avec un humain dans le rôle de l'évaluateur. Un évaluateur note une sortie une fois qu'elle existe ; un point de validation arrête une action avant qu'elle ait le moindre effet, et c'est ce qui compte pour les envois, les paiements et les suppressions.
Analogie
Dans une banque, un employé débutant peut consulter des comptes et préparer des virements seul. Tout virement au-dessus d'un seuil part dans la corbeille d'approbation d'un superviseur, sous forme de formulaire rempli. L'employé passe à autre chose ; le superviseur signe, corrige le montant ou renvoie le dossier avec une note. L'employé est l'agent, la grille des seuils est la politique, le formulaire est la demande d'approbation, la corbeille est l'état sauvegardé, et le superviseur est le validateur.
L'analogie s'arrête à deux endroits. Un employé se souvient du dossier pendant qu'il attend ; un agent ne se souvient de rien si son état n'a pas été sauvegardé. Et un superviseur qui signe deux cents formulaires par jour sans les lire, c'est justement le problème du tampon automatique que ce pattern doit éviter.
Structure
- Boucle d'agent. N'importe quel agent ou workflow : une boucle ReAct, un exécuteur de plan, le worker d'un superviseur. Elle propose un appel d'outil, un plan, un brouillon ou une question.
- Filtre de politique. Du code hors du modèle qui associe chaque proposition à allow (autoriser), ask (demander à un humain) ou deny (refuser), d'après l'outil, ses arguments, un niveau de risque, le mode de permission et les règles « toujours autoriser » mémorisées. Un appel refusé revient au modèle sous forme d'erreur d'outil avec un motif, pour qu'il puisse replanifier.
- Exécution de l'outil. Les appels autorisés s'exécutent tout de suite ; les appels approuvés ou modifiés s'exécutent après la reprise. Chaque appel soumis à validation porte une clé d'idempotence, pour qu'une nouvelle tentative ou un double clic ne l'exécute pas deux fois.
- Pause et sauvegarde. Construit la demande d'approbation (résumé, raison, arguments, impact, décisions possibles, expiration) et sauvegarde les messages, les appels en attente et la position dans un stockage durable indexé par identifiant de thread. Puis rend la main ; aucun processus n'attend.
- Validateur. Une personne qui a l'autorité et le contexte, jointe là où elle travaille déjà. Un minuteur applique un comportement sûr par défaut (ne pas agir, ou escalader vers un autre validateur) si personne ne répond.
- Reprise. Authentifie le validateur, rattache la décision à l'identifiant de la demande enregistrée, revérifie les préconditions après une longue attente, applique la décision une seule fois, et place le résultat (ou le message de rejet) dans la conversation comme résultat d'outil.
- Journal d'audit. Un enregistrement en ajout seul de chaque demande, décision, validateur, horodatage et de ce qui a réellement été exécuté. Il fournit aussi les taux d'approbation, de modification et de rejet qui servent à ajuster la politique.
Générateur de prompt
Listez les outils de l'agent et indiquez lesquels s'exécutent librement, lesquels nécessitent un humain et lesquels sont interdits. Le générateur écrit la section du prompt système de l'agent qui explique les validations et les rejets, une politique de validation à implémenter dans votre harness (LangGraph, OpenAI Agents SDK, Claude Agent SDK ou votre propre boucle), la demande d'approbation que voit le validateur, et en option un prompt pour un pré-validateur automatique.
Prompt généré
Le texte surligné vient du formulaire. Le texte [entre crochets] reste à remplir.
Le prompt système ne fait qu'orienter ce que le modèle tente. Les appels qui se mettent en pause doivent être imposés par le harness avant l'exécution de tout outil, comme la documentation de Claude Code y insiste pour ses propres règles de permission. Traitez la partie 2 comme une spécification de ce code. La qualité de la demande d'approbation (partie 3) détermine ensuite si les validateurs la lisent ou cliquent sans regarder.
Quand l'utiliser
À utiliser quand
- Les actions sont irréversibles ou coûteuses. Paiements, messages externes, suppressions, déploiements et changements de permissions ne se rattrapent pas avec une meilleure étape suivante.
- L'intention est ambiguë ou les préférences comptent. L'agent agit pour quelqu'un qui peut vouloir un autre ton, une autre conception ou un autre compromis que celui qu'il choisirait.
- Les erreurs ont un impact juridique, de sécurité ou de réputation. Ou la réglementation exige une surveillance, comme l'article 14 de l'AI Act européen pour les systèmes à haut risque.
- L'agent travaille sur des systèmes que vous ne pouvez pas isoler dans un sandbox. Bases de données de production et vrais comptes clients.
- Vous en êtes au début du déploiement. Commencez avec des validations, mesurez les taux d'approbation et de modification, et relâchez les niveaux toujours approuvés.
- L'agent a besoin de quelque chose que seule une personne possède. Des identifiants, un accès ou une décision métier. Dans les données d'Anthropic, 12 % des arrêts que Claude Code déclenche de lui-même sont des demandes d'identifiants ou d'accès.
À éviter quand
- Les actions sont en lecture seule ou entièrement réversibles dans un sandbox. Laissez-les s'exécuter et vérifiez le résultat, ou auditez après coup.
- Les validateurs approuvent presque tout sans lire. Ce point de validation n'est qu'une façade. Remplacez-le par un sandbox, une liste d'autorisations, un classifieur automatique ou un audit a posteriori.
- La latence est critique et aucun humain ne peut répondre à temps. Concevez des comportements sûrs par défaut plutôt que d'attendre.
- Le validateur ne peut pas juger la demande. Approuver des commandes shell opaques ajoute de la responsabilité, pas de la sécurité. Améliorez la demande ou envoyez-la à quelqu'un de qualifié.
- L'étape risquée peut être supprimée par conception. Dans une chaîne fixe, écrivez un brouillon au lieu d'envoyer, ou rendez l'étape réversible.
Mise en œuvre
- Inventoriez les outils et les sorties. Pour chacun : modifie-t-il un état hors du sandbox, peut-on l'annuler, qui est concerné, combien coûte-t-il, des données sortent-elles ?
- Attribuez des niveaux de risque et une politique par niveau. L'approbation doit suivre le risque, l'irréversibilité et l'incertitude, pas l'importance apparente d'un outil. Les outils inconnus ou nouveaux passent par défaut en ask (fermé en cas de doute).
- Évaluez deny avant ask, et ask avant allow. Claude Code vérifie les règles dans cet ordre et la première qui correspond l'emporte, si bien qu'un allow étroit ne peut pas annuler un deny large. Demandez quand les arguments ne peuvent pas être analysés : l'OpenAI Agents SDK exige une approbation manuelle quand les arguments sont mal formés, et Claude Code demande confirmation pour les commandes shell qu'il ne parvient pas à analyser entièrement.
- Choisissez où placer la validation. Avant l'exécution d'un outil (approbation), après la production d'un artefact (relecture), au niveau du plan (approbation du plan) ou lors d'un handoff (escalade).
- Utilisez un stockage d'état durable et un schéma d'identifiants de thread. Les checkpointers en mémoire servent aux tests. Ne stockez pas de secrets dans l'état sérialisé du run.
- Définissez les contrats de demande et de décision. Le serveur garde la demande en attente ; la décision ne fait que la référencer par son identifiant. Validez les arguments modifiés avec le schéma de l'outil, et échappez le texte écrit par le modèle quand vous l'affichez, car le modèle a pu lire du contenu injecté.
- Construisez l'interface du validateur et les notifications. Choisissez sync ou async, fixez un délai avec un comportement sûr par défaut, et envoyez les demandes à la personne responsable de la ressource.
- Rendez les effets de bord idempotents et la reprise atomique. Associez une clé d'idempotence à chaque appel soumis à validation et utilisez un compare-and-set sur le statut du run, pour que deux clics ou deux workers ne puissent pas exécuter deux fois.
- Renvoyez les rejets au modèle. La raison du validateur revient sous forme d'erreur d'outil, pour que l'agent replanifie au lieu de retenter le même appel.
- Ajoutez des conditions d'arrêt et mesurez. Nombre maximal d'itérations, seuils de refus, budgets et arrêt d'urgence. Suivez les taux d'approbation, de modification, de rejet et d'expiration ainsi que le délai de décision, puis ajustez les niveaux pour que les gens voient peu de demandes, et des demandes qui comptent.
| Niveau | Exemples | Politique |
|---|---|---|
| T0 lecture seule | Recherche, lecture d'un fichier, consultation d'une commande | Autoriser et journaliser |
| T1 réversible, local | Modifier des fichiers dans un espace de travail git, créer un brouillon | Autoriser dans le sandbox |
| T2 externe mais borné | Commandes shell, API internes, accès à un nouveau domaine | Liste d'autorisations pour les motifs connus comme sûrs ; demander pour le reste, ou laisser un classifieur décider avec un humain en recours |
| T3 conséquent | Écrire aux clients, rembourser sous le plafond, déployer en staging, fusionner une PR | Demander à un humain |
| T4 critique ou irréversible | Paiements au-delà du plafond, suppressions en production, changements de permissions, engagements juridiques | Demander à un humain qualifié, éventuellement deux ; ou interdire à l'agent |
Le chemin de pause et de reprise, indépendamment de tout framework (simplifié à partir des notes de recherche) :
def run(thread_id, decisions=None):
state = store.load(thread_id)
for d in decisions or []: # chemin de reprise
pending = state.pending.pop(d.request_id) # doit correspondre à une demande enregistrée
assert authorized(d.reviewer, pending)
if d.type in ("approve", "edit"):
call = pending.call if d.type == "approve" else pending.call.with_args(validated(d.args))
state.messages.append(execute(call, key=pending.request_id))
else: # rejet : la raison va au modèle
state.messages.append(tool_error(pending.call, d.message))
audit.log(pending, d)
for step in range(MAX_STEPS): # boucle normale
reply = llm(state.messages, tools)
if not reply.tool_calls:
store.save(state); return Done(reply.text)
for call in reply.tool_calls:
verdict = gate(call) # du code, pas le modèle
if verdict == "allow": state.messages.append(execute(call, key=call.id))
elif verdict == "deny": state.messages.append(tool_error(call, "Blocked by policy"))
else: state.pending[new_id()] = ApprovalRequest.from_call(call)
if state.pending: # chemin de pause
store.save(state); notify(state.pending); return Paused(state.pending)
return Escalate("max steps reached")
| Framework | Forme que prend ce pattern |
|---|---|
| LangGraph | interrupt(value) dans un nœud met le graphe en pause et sauvegarde l'état via le checkpointer ; Command(resume=...) avec le même thread_id reprend. Le nœud redémarre depuis le début à la reprise, donc placez les effets de bord après l'interruption. Les options statiques interrupt_before/interrupt_after sont prévues pour le débogage. |
| LangChain agents | HumanInTheLoopMiddleware avec interrupt_on par outil et les décisions approve, edit, reject, respond. Agent Inbox est une interface de validation open source pour ces interruptions. |
| OpenAI Agents SDK | needs_approval sur un outil (un booléen ou une fonction des arguments) ; le run renvoie des interruptions ; sérialisez le RunState, puis approve ou reject et relancez. Le SDK n'authentifie ni les validateurs ni les instantanés : c'est à votre serveur de le faire. |
| Claude Code / Claude Agent SDK | Règles allow, ask et deny plus modes de permission (default, acceptEdits, plan, auto, dontAsk, bypassPermissions), le callback canUseTool, AskUserQuestion, et un hook PreToolUse qui peut renvoyer defer pour que le processus se termine et reprenne plus tard. |
| Microsoft Agent Framework | Des function tools qui exigent une approbation ; le run renvoie des demandes d'approbation au lieu d'une réponse, et les réponses sont rattachées aux demandes en attente dans la même session. |
| Google ADK | FunctionTool(require_confirmation=...) ou tool_context.request_confirmation(...) ; LongRunningFunctionTool met le run en pause jusqu'à ce que le client le relance. |
| CrewAI | Task(human_input=True) pour faire relire une réponse finale ; @human_feedback dans les Flows aiguille selon le verdict, avec un default_outcome. |
| Temporal | Le workflow attend un Signal avec un délai. L'attente ne consomme pas de calcul, les minuteurs survivent aux plantages, et l'historique du workflow sert aussi de piste d'audit. |
| AutoGen | UserProxyAgent (bloquant, dans le processus) ou HandoffTermination(target="user") pour arrêter l'équipe et reprendre après avoir recueilli la réponse. |
Mise en garde. Ces API évoluent vite. Les détails liés à une version (le response_schema de LangGraph sur interrupt(), les options when et per_call de LangChain, les renommages du Microsoft Agent Framework) reflètent la documentation consultée en novembre 2026. La documentation de Google ADK indique que la confirmation d'outil n'est pas prise en charge avec DatabaseSessionService ni VertexAiSessionService, ce qui y limite l'approbation asynchrone durable. Le SDK d'approbation HumanLayer, souvent cité pour les approbations par Slack et par e-mail, est à considérer comme historique : son dépôt décrit désormais un autre produit. Les détails sur Microsoft Agent Framework, CrewAI et Temporal ci-dessus ont été sourcés mais pas revérifiés, pas plus que la sémantique exacte de la décision defer du hook dans le Claude Agent SDK ni les limites de son outil AskUserQuestion.
Variantes
Validation des appels d'outils
La forme par défaut : certains outils, ou les appels qui remplissent une condition, se mettent en pause pour être approuvés, modifiés ou rejetés avant de s'exécuter. Tous les grands frameworks la prennent en charge nativement. L'exemple de la documentation ADK ne demande que lorsqu'un montant dépasse 1000.
Approbation du plan
L'agent rédige un plan, un humain l'approuve ou le modifie, puis les étapes s'exécutent sans demande à chaque étape. Une seule relecture couvre de nombreuses actions, si bien que les gens sont sollicités moins souvent et que chaque demande pèse davantage. Le mode plan de Claude Code explore en lecture seule avant de présenter un plan. Voir Plan-and-Execute.
Relecture de la sortie (brouillon, puis envoi)
L'agent produit un e-mail, une PR ou un rapport, et un humain le relit avant publication. Dans l'exemple suivi ici, l'agent rédige librement l'e-mail au client et seul l'envoi est soumis à validation.
Question de clarification, ou humain comme outil
Le modèle appelle un outil « demander à l'humain » quand il a un doute et reçoit la réponse comme résultat d'outil. Anthropic a constaté que, sur les tâches les plus complexes, Claude Code s'arrête pour demander une clarification plus de deux fois plus souvent que les humains ne l'interrompent. Les questions à l'initiative du modèle complètent une politique en code ; elles ne la remplacent pas, car savoir quand demander reste un problème ouvert (Feng et al.).
Escalade ou handoff vers un humain
L'agent transfère la conversation à une personne quand il ne peut pas ou ne doit pas continuer, comme le font les agents de support vers des conseillers. AutoGen l'implémente avec HandoffTermination(target="user"). Voir Swarm / Handoffs.
Classifieur comme validateur, avec escalade vers un humain
Un modèle examine les actions de routine, et seules les actions bloquées ou ambiguës arrivent à une personne. Le mode auto de Claude Code fonctionne ainsi et rend la main à l'humain après 3 refus consécutifs ou 20 refus au total (en mode headless, il s'arrête). Anthropic a mesuré sur l'ensemble du pipeline un taux de faux positifs de 0,4 % sur 10 000 appels d'outils réels et un taux de faux négatifs de 17 % sur 52 actions trop zélées réelles, et précise que cela ne remplace pas une relecture humaine attentive sur une infrastructure à fort enjeu (chiffres publiés par l'éditeur).
Confiance progressive et modes de permission
Commencez de façon restrictive et assouplissez à mesure que la confiance s'installe : règles « toujours autoriser » limitées à un outil et à un motif d'arguments, ou mode qui approuve automatiquement les modifications dans le projet. Anthropic indique que l'approbation automatique complète passe d'environ 20 % des sessions chez les nouveaux utilisateurs de Claude Code à plus de 40 % après 750 sessions.
Human on the loop
Pas de validation bloquante : une personne suit un flux d'activité en direct et peut interrompre, réorienter ou arrêter. Dans les mêmes données d'Anthropic, les interruptions passent d'environ 5 % à environ 9 % des tours avec l'expérience : la surveillance passe de l'approbation de chaque étape au suivi.
Relecture a posteriori
Les actions s'exécutent, et des humains relisent un échantillon ou la totalité des journaux après coup. C'est de l'audit, pas de la validation, et cela ne convient qu'aux actions réversibles ou à faible impact.
Modification de l'état, retour arrière et embranchement
L'humain modifie l'état de l'agent, ou revient à un point de contrôle antérieur et crée une nouvelle branche (update_state de LangGraph sur un ancien checkpoint). Utile pour corriger une hypothèse erronée faite plusieurs étapes plus tôt.
Quatre yeux (deux validateurs)
Deux personnes qualifiées doivent confirmer. L'AI Act européen l'exige avant d'agir sur la sortie de certains systèmes d'identification biométrique à distance. Utilisez-le pour le niveau T4.
Niveaux d'autonomie
Feng, McDonald et Zhang décrivent cinq rôles de l'utilisateur : opérateur, collaborateur, consultant, approbateur et observateur. La plupart des implémentations de cette page relèvent du consultant ou de l'approbateur ; au niveau observateur, le seul contrôle restant est un interrupteur d'arrêt d'urgence.
Avantages et inconvénients
Avantages
- Intercepte les actions plausibles mais non voulues avant qu'elles aient un effet, ce qu'aucune vérification après coup ne peut faire pour un paiement ou un e-mail envoyé.
- Chaque décision soumise à validation devient un événement explicite et journalisé, avec un validateur nommé, ce qui aide au débogage et à la conformité.
- Les modifications sont des données étiquetées : un taux de modification élevé montre précisément où les propositions de l'agent sont faibles.
- Fonctionne avec n'importe quel pattern, et les grands frameworks fournissent la mécanique de pause et de reprise.
- Permet de déployer tôt et d'assouplir les validations d'après des taux d'approbation mesurés plutôt que des suppositions.
Inconvénients
- La valeur dépend de l'attention. Avec 93 % d'acceptation des demandes dans Claude Code, une grande partie se perd si les demandes ne sont pas rares et significatives.
- La latence passe de quelques secondes à plusieurs jours, et un run ne va pas plus vite que son validateur le plus lent.
- L'attention humaine devient la limite de débit ; le temps humain coûte bien plus cher que les tokens.
- L'état durable, l'idempotence, la sémantique de reprise, l'authentification des validateurs, les notifications et l'interface de relecture sont à votre charge. Les frameworks ne couvrent que la pause et la reprise.
- Des approbations données par réflexe peuvent faire porter la faute à des personnes qui n'avaient aucune chance réaliste de repérer l'erreur.
Modes de défaillance
- Lassitude d'approbation
-
Les validateurs approuvent sans lire. Les signes : des approbations en moins d'une seconde sur des demandes complexes, et des taux d'approbation proches de 100 %.
Parade : soumettre à validation moins d'actions, à plus fort enjeu, et mettre le reste dans un sandbox (Anthropic indique que le sandboxing a réduit de 84 % les demandes de permission de Claude Code en interne). Afficher des étiquettes de risque, suivre le délai de décision, et envisager d'injecter des demandes pièges connues comme mauvaises pour mesurer le taux de détection, avec prudence et en toute transparence.
- Biais d'automatisation
-
Les gens font trop confiance à la proposition de l'agent ou ratent ce qu'il n'a pas signalé. Dans l'étude de Goddard sur 26 médecins généralistes britanniques, des conseils exacts à 70 % ont amélioré la précision globale, mais dans 5,2 % des cas un médecin est passé d'une bonne réponse à la mauvaise réponse du système. Ces résultats viennent des domaines clinique et aéronautique, pas d'écrans d'approbation pour LLM.
Parade : montrer les éléments de preuve, pas seulement la recommandation ; rendre les validateurs responsables de leurs décisions ; exiger une justification ou une modification pour le niveau le plus élevé.
- Demande peu informative
-
« Autoriser l'exécution de l'outil ? » suivi de JSON brut. Le validateur ne peut pas juger et clique sur oui.
Parade : un générateur de demandes qui affiche un résumé, la raison donnée par l'agent, l'impact, un diff ou un aperçu, et si l'action est réversible.
- Demande trompeuse (prompt injection)
-
L'agent a lu du contenu injecté et rédige une description d'apparence inoffensive pour un appel nuisible.
Parade : afficher les arguments exacts à côté du résumé du modèle, échapper le texte non fiable, et conserver des règles deny et un sandbox qu'aucune approbation ne peut lever.
- « Toujours autoriser » trop large
-
Une approbation mémorisée pour un contexte s'applique ailleurs : à un autre agent après un handoff, ou à un outil de remplacement qui porte le même nom. OpenAI et Microsoft documentent tous deux ce risque pour leurs approbations persistantes.
Parade : limiter les règles à un outil, un motif d'arguments, un agent et un espace de travail ; les faire expirer ; revoir les règles enregistrées quand les outils changent.
- Décisions falsifiées ou rejouées
-
Un client soumet une approbation pour un appel qui n'a jamais été en attente, ou avec d'autres arguments.
Parade : garder les demandes en attente sur le serveur, rattacher chaque décision à un identifiant de demande et à une session, authentifier le validateur via l'authentification de votre application, et n'accepter de nouveaux arguments qu'à travers une modification validée.
- Double exécution à la reprise
-
Deux clics, une nouvelle tentative, ou un plantage après l'exécution de l'outil mais avant la sauvegarde de l'état, et le remboursement est répété. La documentation d'OpenAI prévient que l'approbation seule ne garantit pas une exécution unique.
Parade : clés d'idempotence, transitions d'état atomiques, et rapprochement avec le système de paiement avant toute nouvelle tentative.
- Effets de bord rejoués avant la pause
-
Dans LangGraph, le code situé avant
interrupt()s'exécute de nouveau à la reprise et duplique des enregistrements. Untry/exceptnu autour deinterrupt()avale la pause.Parade : placer les effets de bord après l'interruption ou dans un autre nœud, utiliser des upserts, et respecter les règles d'ordre du framework.
- Approbation périmée
-
Approuvé hier, exécuté aujourd'hui dans un monde qui a changé : la commande avait déjà été remboursée par un collègue.
Parade : une expiration sur les demandes, des préconditions revérifiées à la reprise, et l'heure de création affichée au validateur.
- Pas de délai, ou un délai qui approuve
-
Les runs restent bloqués indéfiniment, ou le silence vaut consentement.
Parade : des minuteurs durables dont le comportement par défaut est de ne pas agir, ou d'escalader vers le validateur suivant.
- Boucles de refus et contournement de la validation
-
L'agent retente une action bloquée, la reformule (
/bin/rmau lieu derm,sh -c) ou la découpe en étapes autorisées. La documentation de Claude Code prévient qu'une règle deny surcurlne couvre pas le même programme appelé par son chemin.Parade : des messages de rejet qui expliquent et suggèrent des alternatives, des compteurs de refus qui arrêtent le run, et un sandbox au niveau du système d'exploitation, puisque les règles sur le texte des commandes ne constituent pas une frontière de sécurité.
- Contrôles ignorés sans bruit
-
Dans le Claude Agent SDK, les appels approuvés automatiquement par une règle ou un mode n'atteignent jamais
canUseTool, donc les contrôles placés là ne s'exécutent pas.Parade : placer les contrôles obligatoires dans un hook
PreToolUse, qui s'exécute pour chaque appel. - Goulot d'étranglement humain
-
La file s'allonge, les agents attendent, et les utilisateurs passent à un mode de contournement.
Parade : mesurer la longueur de la file et le temps d'attente, automatiser là où l'approbation frôle 100 %, ajouter des validateurs, et regrouper les demandes liées.
Liens avec les autres patterns
- Prompt Chaining : une validation humaine entre deux étapes, par exemple l'approbation du plan d'un texte avant sa rédaction.
- Routing : l'une des routes est une file d'attente humaine, utilisée pour les classifications peu sûres ou sensibles.
- Parallelization : chaque branche parallèle peut s'interrompre, et toutes peuvent reprendre en un seul lot ; un humain peut départager un vote à égalité.
- Evaluator–Optimizer : l'humain est l'évaluateur, ou la cible de l'escalade quand la boucle atteint son plafond d'itérations.
- ReAct (tool-use loop) : le point d'insertion le plus courant. La validation se place entre « le modèle propose un appel d'outil » et « le harness l'exécute », et demander à l'humain peut être l'un des outils.
- Plan-and-Execute : approuver ou modifier le plan avant l'exécution, puis de nouveau quand l'agent replanifie.
- Orchestrator–Workers : soumettre à validation les appels d'outils des workers, ou laisser l'orchestrateur escalader les sous-tâches en échec ; dans l'OpenAI Agents SDK, les approbations levées dans des runs imbriqués remontent au niveau supérieur.
- Supervisor : le superviseur peut aiguiller vers un humain comme vers un autre worker, et un humain peut passer outre ses choix.
- Hierarchical teams : l'escalade remonte l'arbre, avec un humain au-dessus du manager de plus haut niveau pour les décisions qui dépassent son autorité.
- Swarm / Handoffs : la cible d'un handoff peut être une personne ; les approbations mémorisées ne doivent pas passer d'un agent à l'autre lors d'un handoff.
- Group Chat : l'humain est un participant, ou prend le rôle de celui qui choisit le prochain intervenant.
- Blackboard : des personnes publient sur le tableau ou valident les entrées avant qu'elles fassent foi.
- Council / Debate : un humain joue le rôle de juge ou départage les positions des membres.
Pour aller plus loin
Toutes les sources ci-dessous sont en anglais.
- Interrupts (documentation LangGraph) :
interrupt()etCommand(resume), pourquoi les nœuds se réexécutent à la reprise, et les règles qui évitent de casser les pauses. - Human-in-the-loop (documentation de l'OpenAI Agents SDK) : approbation des outils, sérialisation de l'état du run, et une section claire sur la sécurisation des approbations et la prévention des doubles exécutions.
- Configure permissions (documentation Claude Code) : règles allow, ask et deny, leur ordre d'évaluation, les modes de permission, et pourquoi les règles sur le texte des commandes ne sont pas une frontière de sécurité.
- Claude Code auto mode (Anthropic) : le chiffre de 93 % d'acceptation, un classifieur qui remplace la plupart des demandes, et ses taux d'erreur mesurés.
- Measuring AI agent autonomy in practice (Anthropic) : comment les comportements d'approbation et d'interruption des utilisateurs évoluent avec l'expérience, et pourquoi les agents s'arrêtent pour poser des questions.
- Levels of Autonomy for AI Agents (Feng, McDonald, Zhang, arXiv) : cinq rôles pour l'utilisateur, de l'opérateur à l'observateur, et les questions ouvertes sur l'approbation par réflexe et sur le moment où il faut demander.
Sur les chiffres. Le chiffre de 93 % vient de l'article d'Anthropic sur le mode auto (mars 2026), sans taille d'échantillon ni période publiées. Des articles secondaires citent 97 % d'après une annonce ultérieure d'Anthropic qui n'a pas pu être retrouvée ; ce chiffre n'est donc pas utilisé ici. Les statistiques d'Anthropic sur l'implication humaine dans le trafic de l'API sont des bornes supérieures déclarées par un seul éditeur, sur sa propre plateforme.