Que sont les actions d’agents avec validation humaine ?

Les actions d’agents avec validation humaine sont des écritures qu’un agent d’IA propose et qu’une personne valide avant exécution. La personne ne tranche qu’une question : cet appel précis doit-il avoir lieu ? La couche d’actions impose le reste dans tous les cas : une exécution au plus, sur l’état que la personne a vu, avec les droits de l’utilisateur, et une trace.

Cette couche est la troisième de l’architecture de plateforme IA d’entreprise, à construire en dernier, une fois l’identité et le journal de décisions en place ; la check-list des serveurs MCP qui écrivent dit quoi exiger d’un fournisseur.

La couche d’actions en un coup d’œil

Étape ou garantie La règle Où elle est imposée Comment la tester
Proposer Un outil du manifeste, avec des arguments conformes à son schéma Le serveur, face au manifeste épinglé Appeler un outil absent du manifeste : refus
Valider Une personne valide les paramètres que le serveur affiche Une validation liée à une empreinte, écrite par le seul service de validation Modifier un paramètre après validation : refus
Exécuter, une fois Une validation, une clé, une exécution au plus, avant expiration La clé primaire de l’enregistrement d’exécution Envoyer deux fois l’appel validé, puis en parallèle : une exécution
État à l’exécution La fiche est telle que le valideur l’a vue If-Match, ou une version dans la clause WHERE Modifier la fiche après validation : aucune écriture
Le journal Chaque étape ajoutée et exportée Droits d’insertion seuls, S3 Object Lock en mode compliance ; j’y ajouterais un chaînage par empreintes Modifier une ligne avec le rôle du serveur : refus
Identité Les droits de l’utilisateur, jamais plus Token exchange à chaque appel ; IRSA pour les accès AWS Un utilisateur sans droit de remboursement en demande un : la cible refuse

Le flux : proposer, valider, exécuter

Les lectures s’exécutent sans validation. Chaque écriture est un enregistrement qui change d’état, pas un appel que l’agent passe lui-même. L’agent ne fait que créer des propositions ; seul le service de validation les valide ou les rejette, et une validation inutilisée expire ; seul le serveur d’actions en fait passer une à « en cours », puis à réussie ou échouée.

Une proposition contient l’outil et la version du manifeste, la fiche visée, les arguments conformes au schéma, l’état attendu de la fiche, l’utilisateur tiré du jeton vérifié et la session de l’agent qui l’a produite. La validation porte sur une empreinte de l’ensemble, calculée sur du JSON canonique (RFC 8785) pour que deux encodages des mêmes arguments concordent.

La personne voit ce que le serveur construit à partir de cet enregistrement, jamais le texte de l’agent : la cible, chaque paramètre, l’identité sous laquelle l’appel s’exécutera. J’afficherais aussi les valeurs actuelles à côté des nouvelles, pour que le valideur juge un changement plutôt qu’un formulaire ; les valeurs lues deviennent la précondition.

Coût : une lecture de la cible par proposition, et un écran à construire. Test : faites décrire à l’agent un remboursement de 10 alors qu’il en propose un de 100 ; l’écran affiche 100.

Un serveur d’actions MCP unique, des manifestes d’outils versionnés

Quand les agents appellent directement les API métier, chaque intégration décide seule de ce qu’ils peuvent faire et journaliser, et rien ne se relit en un seul endroit. Toute action d’agent passe donc par un serveur d’actions MCP unique. C’est lui, et non l’agent, qui dispose des moyens d’atteindre les systèmes métier, et il n’expose que les outils que ses manifestes définissent.

Un manifeste est votre description d’un outil, relue comme du code : nom et version, schémas JSON d’entrée et de sortie (les inputSchema et outputSchema de MCP), lecture ou écriture, système cible et audience du jeton, champs qui forment l’état attendu, clé d’idempotence acceptée ou non par la cible, validation requise ou non. C’est ici que se décide le classement, car la page Tools de MCP impose (MUST) aux clients de tenir les annotations d’outils pour non fiables, sauf si elles viennent de serveurs de confiance.

Une proposition cite la version de son manifeste : une décision se lit donc au regard du manifeste en vigueur au moment de sa validation. Si une nouvelle version sort avant l’exécution, je refuserais l’écriture et ferais reproposer l’agent. Faites passer le jeu de référence à chaque changement de manifeste.

Coût : une revue par nouvel outil ou champ ; une revalidation des écritures en attente à chaque version. Test : publiez une version entre validation et exécution ; l’écriture est refusée.

Idempotence : la validation sert de clé

L’identifiant de la validation est la clé d’idempotence : une validation, une exécution au plus. L’identifiant JSON-RPC ne convient pas, car une requête perdue avec un flux interrompu est réémise sous un nouvel identifiant (changelog ; voir ce que change la révision 2026-07-28).

Voici une esquisse minimale, qui n’est le code d’aucun système en production ; sur PostgreSQL 18 en Read Committed, le niveau par défaut, elle se comporte comme décrit :

CREATE TABLE approvals (
  approval_id uuid PRIMARY KEY,
  params_hash bytea NOT NULL,
  expires_at  timestamptz NOT NULL
);

CREATE TABLE executions (
  approval_id uuid PRIMARY KEY REFERENCES approvals,
  result      jsonb
);

INSERT INTO executions (approval_id)
SELECT approval_id FROM approvals
WHERE approval_id = $1 AND params_hash = $2 AND expires_at > now()
ON CONFLICT (approval_id) DO NOTHING
RETURNING approval_id;

Une ligne en retour : exécutez l’écriture. Sinon, vérifiez dans cet ordre :

  1. Une empreinte différente de celle de la validation : refus, le 422 du projet IETF sur l’en-tête Idempotency-Key (expiré en avril 2026 : une référence de conception, pas une norme).
  2. Un résultat enregistré : renvoyez-le, succès ou erreur, comme le suggère ce projet.
  3. Un résultat NULL : une tentative en cours, ou un résultat inconnu après un dépassement de délai. Répondez « en cours », le 409 du projet, et n’exécutez rien.
  4. Aucun enregistrement : la validation a expiré ou n’a jamais existé.

Une réservation concurrente attend la fin de la première transaction et, après son COMMIT, ne reçoit aucune ligne. En Repeatable Read ou Serializable, elle lève plutôt une erreur de sérialisation, et relancer la transaction ne renvoie aucune ligne. Une seule réservation aboutit.

Terminez la réservation par un COMMIT avant d’appeler la cible : si sa transaction est annulée (ROLLBACK) après l’appel, un nouvel essai réserve à nouveau et l’écriture s’exécute deux fois. Transmettez l’identifiant de validation à la cible quand elle accepte une clé.

Conservez chaque enregistrement d’exécution au moins jusqu’à l’expiration de sa validation, sinon une purge rouvre la brèche ; je le garderais avec le journal, pour les essais tardifs. Coût : une ligne et un aller-retour par écriture. Test : réservez deux fois, puis depuis deux sessions simultanées ; une seule ligne revient.

Préconditions : vérifier l’état que le valideur a vu

Une précondition est l’état que la validation supposait : la version lue lors de la proposition et les conditions métier du manifeste (« la facture est impayée »). Quelqu’un peut payer la facture avant l’exécution : vérifiez donc la précondition dans la même opération que l’écriture.

En HTTP, envoyez If-Match, la protection habituelle contre les mises à jour perdues ; le serveur ne doit pas appliquer la méthode si l’étiquette d’entité ne correspond plus, et peut répondre 412 (RFC 9110). Sur une base que vous maîtrisez :

UPDATE invoices SET status = 'refunded', version = version + 1
WHERE id = $1 AND status = 'unpaid' AND version = $2;  -- 0 rows: the state changed

En Read Committed, si une mise à jour concurrente aboutit d’abord (COMMIT), cette instruction réévalue sa clause WHERE sur la nouvelle version de la ligne et ne modifie rien. Une cible qui n’offre ni l’un ni l’autre impose de lire puis d’écrire, avec une fenêtre de concurrence ; notez-le dans son manifeste.

Une précondition en échec impose de reproposer, jamais de forcer, car forcer transforme une validation périmée en écriture que personne n’a validée. Après un résultat inconnu, lisez d’abord : un 412 peut signifier que votre première tentative a abouti, cas où la RFC 9110 permet au serveur de répondre par un succès.

Coût : une version sur chaque cible ; des revalidations sur les fiches très sollicitées. Test : modifiez la fiche après validation ; rien n’est écrit et le journal dit pourquoi.

Le journal de décisions : append-only et exporté

Le journal de décisions enregistre chaque proposition, validation, refus, expiration et exécution dans la même transaction que l’étape : pas d’entrée, pas d’étape. Une entrée contient l’étape et ses identifiants, la version du manifeste, l’empreinte des paramètres, des références aux arguments, l’état attendu, l’utilisateur (pour une exécution, sub et act tirés du jeton échangé), le valideur, une empreinte de l’écran affiché et le résultat.

Append-only signifie que les entrées ne sont jamais modifiées ; les corrections sont de nouvelles entrées. Les droits l’imposent à l’application : le rôle du serveur reçoit INSERT et SELECT, et la table appartient à un rôle avec lequel personne ne se connecte. Propriétaires et superutilisateurs gardent leurs droits (privilèges) : je chaînerais donc aussi les entrées, chacune stockant un SHA-256 de l’empreinte précédente et de son propre contenu.

Recalculer la chaîne détecte une ligne modifiée ou supprimée, mais pas un propriétaire qui réécrit une ligne et toutes les empreintes suivantes, ni la suppression des dernières lignes. L’empreinte exportée les révèle jusqu’à son export ; les entrées plus récentes ne sont protégées que par la base. Gardez les données personnelles hors du contenu chaîné, dans une table que vous pouvez effacer, car caviarder une entrée chaînée casse la chaîne (la check-list traite de l’effacement).

Exportez chaque lot, avec sa dernière empreinte, vers S3 Object Lock en mode compliance : aucun utilisateur, pas même root, ne peut alors écraser ni supprimer une version d’objet verrouillée, changer son mode ou raccourcir sa conservation, et seule la suppression du compte AWS l’efface avant terme (S3 Object Lock).

Rejouer une décision, c’est la reconstituer depuis le journal ; on ne renvoie jamais l’écriture.

Coût : des ajouts en série et un export à exploiter. Test : altérez une ligne dans une copie ; la vérification de la chaîne y échoue.

Identité : l’appel porte les droits de l’utilisateur

L’écriture porte un jeton émis pour la cible en échange de celui de l’utilisateur (RFC 8693) : la cible applique donc les droits de l’utilisateur. En délégation, si votre fournisseur d’identité l’émet, la claim act désigne le serveur ; journalisez sub et act depuis ce jeton, jamais depuis la requête de l’agent.

Pour ses propres accès AWS, comme l’export, le serveur passe par les rôles IAM pour comptes de service : des identifiants temporaires par compte de service, isolés entre pods seulement si l’accès aux métadonnées d’instance est restreint. La couche 5 de l’architecture de plateforme détaille l’échange.

Coût : un fournisseur d’identité et des cibles qui prennent en charge l’échange. Test : décodez le jeton reçu par la cible ; sub doit désigner l’utilisateur et, en délégation, act le serveur.

Quand une pièce tombe, les écritures s’arrêtent

La couche bloque par défaut. Si elle ne peut pas montrer qu’une action est validée, à jour et journalisée, rien ne s’exécute.

  • Service de validation indisponible : les propositions attendent et aucune ne s’exécute. Les écritures en attente ont besoin d’un responsable ; un délai dépassé ne vaut jamais validation.
  • Validation expirée : la réservation ne renvoie aucune ligne et l’agent repropose. Je garderais des validations de courte durée, car la précondition détecte une fiche modifiée, pas une décision périmée.
  • Journal indisponible : la réservation partage la transaction de son entrée, elle échoue donc aussi. Si le journal tombe après l’appel, rapprochez le résultat non enregistré de l’état de la cible.

Coût : une panne du serveur ou de sa base arrête toutes les écritures. Test : retirez au serveur le droit INSERT sur le journal, puis validez une écriture ; aucun enregistrement d’exécution n’apparaît.

En pratique

Sur la plateforme d’ENSO, j’ai spécifié des actions d’agents via un serveur d’actions MCP unique avec des manifestes d’outils versionnés, une validation humaine de chaque écriture, des contrôles d’idempotence et de préconditions, et un journal de décisions en append-only qui rend chaque décision de l’IA rejouable, avec un export WORM vers S3 Object Lock. L’IA hérite des droits de l’utilisateur via OAuth2 Token Exchange (Keycloak, OIDC) et des identités de workload IRSA. L’architecture complète est décrite dans l’étude de cas ENSO, et le service sur la page gouvernance des agents IA.

Compromis et limites

La validation humaine de chaque écriture limite le débit et convient mal à l’automatisation à fort volume et à faible risque. Relâchez-la outil par outil, seulement là où le manifeste classe le risque comme faible, par une modification relue du manifeste ; gardez clé, précondition et journal, qui ne coûtent le temps de personne.

Une couche d’actions est un service de plus à construire et à garder disponible. Son stockage d’idempotence grossit à chaque écriture, et les préconditions en échec coûtent des revalidations, surtout sur les fiches très sollicitées.

La validation n’arrête ni un valideur qui clique sans lire, ni une injection de prompt (un déclencheur d’Excessive Agency) qui produit une proposition plausible : la personne contrôle des paramètres, pas une intention. Les droits de l’utilisateur et les préconditions bornent les dégâts.

Le journal n’est utile que par la discipline qui l’entoure : définissez la conservation, l’accès et l’export avant d’en avoir besoin.

Questions fréquentes

Que signifie la validation humaine pour un agent d’IA qui écrit dans des systèmes métier ?

L’agent propose une écriture ; une personne en valide les paramètres exacts avant l’exécution. Les lectures s’en passent. Le serveur d’actions impose le reste : la validation est liée à une empreinte des paramètres, et l’écriture ne s’exécute qu’une fois, sur une fiche inchangée, avec les droits de l’utilisateur.

Comment rendre idempotente l’écriture d’un agent d’IA ?

Utilisez l’identifiant de la validation comme clé d’idempotence. Insérez un enregistrement d’exécution sous cette clé, avec COMMIT, avant d’appeler la cible. Un nouvel essai le trouve et reçoit le résultat enregistré, ou « en cours », jamais une seconde écriture. Transmettez la même clé à la cible quand elle en accepte une.

Comment journaliser les actions d’un agent d’IA pour l’audit et le rejeu ?

Ajoutez chaque proposition, validation, refus et exécution, avec la version du manifeste et l’empreinte des paramètres, dans la transaction de l’étape. N’accordez au serveur que l’insertion et exportez les lots vers S3 Object Lock en mode compliance ; je chaînerais aussi les entrées par empreinte, données personnelles à part. Rejouer reconstitue une décision sans renvoyer l’écriture.

Que se passe-t-il quand une action d’agent validée dépasse son délai ?

Le résultat est inconnu : la cible a pu appliquer l’écriture. L’enregistrement reste sans résultat, donc les nouveaux essais reçoivent « en cours » et rien ne relance l’écriture. On lit l’état de la cible pour enregistrer succès ou échec ; après un échec, l’agent repropose, et l’écriture qui arrive en second échoue sur sa précondition.

Sources