Lire deux fois ne coûte rien, écrire deux fois coûte cher
Tant qu’un agent se contente de lire, un appel répété ne coûte que des jetons et un peu de latence. Dès qu’il écrit (virement, commande, courriel, ticket, remboursement), la répétition change de nature : elle produit un second effet dans le monde réel, et rien dans la pile technique ne l’empêche par défaut.
Les deux dernières années ont déplacé les agents du côté de l’écriture. Un assistant qui résume des documents ne présente pas ce risque ; un agent branché sur un ERP, une messagerie ou un prestataire de paiement le présente à chaque appel. Le catalogue d’outils qu’on lui expose contient désormais des verbes d’action, et c’est précisément ce qu’on attendait de lui.
Le scénario qui pose problème n’a rien d’exotique, et tous ceux qui ont exploité un système réparti le reconnaîtront. L’agent appelle l’outil. L’outil s’exécute et le virement part. Puis la réponse se perd : un délai d’attente dépassé, une passerelle qui coupe, un conteneur remplacé au mauvais moment. Côté appelant, il ne reste qu’une erreur qui ne dit rien. Et que fait un client bien écrit devant une erreur réseau ? Il réessaie. C’est même ce qu’on lui demande partout ailleurs.
Par défaut, MCP décrit vos outils comme destructeurs et non rejouables
Dans le Model Context Protocol, la rejouabilité d’un outil n’est décrite qu’à un seul endroit : une annotation facultative qu’un serveur déclare lui-même sur ses propres outils, et dont la valeur par défaut est « non ». Les valeurs par défaut des quatre annotations dessinent, sans détour, un outil qui modifie son environnement, qui peut le faire de façon destructive, qu’on ne peut pas rappeler impunément, et dont les effets sortent dans un monde ouvert.
| Annotation | Ce qu’elle déclare | Valeur par défaut |
|---|---|---|
readOnlyHint | L’outil ne modifie pas son environnement | false, donc il le modifie |
destructiveHint | L’outil peut faire des mises à jour destructives plutôt qu’additives | true, donc il le peut |
idempotentHint | Rappeler l’outil avec les mêmes arguments n’a aucun effet supplémentaire | false, donc le rappel a un effet |
openWorldHint | L’outil interagit avec un monde ouvert d’entités externes | true, donc il en sort |
Deux de ces lignes ne comptent que pour les outils qui écrivent : le schéma précise que destructiveHint et idempotentHint ne sont significatives que si readOnlyHintvaut false. Ces valeurs par défaut ne sont pas un aveu de faiblesse, elles sont un choix prudent : faute de déclaration, le protocole suppose le pire. Le comportement à supposer, pour un outil dont le serveur ne déclare rien, est donc « ceci n’est pas rejouable », et rien dans le protocole n’oblige un client à en tenir compte.
Le schéma est d’ailleurs explicite sur le statut de ces champs : ce sont des indications, rien ne garantit qu’elles décrivent le comportement réel de l’outil, et un client ne devrait jamais fonder ses décisions sur les annotations d’un serveur qui n’est pas de confiance. Autrement dit, la seule information de rejouabilité qui circule est à la fois facultative, auto-déclarée et invérifiable. C’est une étiquette, pas un verrou, et la prudence est la même que pour la description d’un outil, qui est une entrée non fiable.
Pourquoi l’appelant ne peut pas savoir si l’action a eu lieu
Trois propriétés de la spécification MCP, chacune justifiée de son côté, rendent le doute impossible à lever : le protocole ne donne au serveur aucun moyen de reconnaître un rejeu, l’appelant ne peut pas distinguer une panne d’un succès perdu, et l’identifiant de la requête ne permet pas de trancher.
Le protocole est sans état, et c’est voulu.La spécification pose que toute l’information nécessaire au traitement d’une requête est contenue dans la requête elle-même, que le serveur traite chaque requête indépendamment, et qu’aucun état ne doit être déduit des requêtes précédentes, y compris sur la même connexion. Un serveur n’a donc, par construction, aucune mémoire de la connexion sur laquelle s’appuyer pour dire « celle-ci, je l’ai déjà vue ».
Le délai d’attente est un événement local.La spécification note que les erreurs purement locales à une implémentation ne reçoivent aujourd’hui aucun code dans le protocole, et elle cite précisément le délai d’attente levé à l’intérieur d’un SDK. Ce silence est logique : l’événement ne vient pas du serveur, il vient de votre propre bibliothèque, qui a cessé d’attendre. Elle ne sait rien de ce qui s’est passé à l’autre bout. « Pas de réponse » et « réponse perdue » arrivent sous la même forme.
L’identifiant de la requête ne peut pas tenir ce rôle. On pourrait espérer que le rejeu réemploie celui de la requête d’origine, ce qui permettrait au serveur de le reconnaître. La règle l’interdit : un identifiant ne doit pas coïncider avec celui d’une requête déjà émise et encore sans réponse, ce qui est exactement le cas d’une requête dont la réponse s’est perdue. Et là où la spécification décrit explicitement une reprise, celle des requêtes à plusieurs allers-retours, elle impose que l’identifiant diffère entre la requête initiale et la reprise. Le rejeu se présente donc au serveur comme une demande neuve, et il n’y a rien d’anormal à cela.
La spécification n’ignore pourtant pas le rejeu. Elle l’aborde justement là, dans ce même mécanisme de reprise, où elle recommande aux serveurs d’inscrire dans l’état qu’ils confient au client de quoi refuser un rejeu : l’identité authentifiée de l’appelant, une expiration courte, et une empreinte de la requête d’origine. Et elle ajoute aussitôt l’avertissement qui compte : ces mesures bornent la fenêtre de rejeu et interdisent la réutilisation de cet état par un autre utilisateur ou sur une autre requête, mais elles ne garantissent pas à elles seules l’usage unique ; un serveur qui exige qu’un état donné ne soit consommé qu’une fois doit le garantir lui-même. Là où elle touche à l’usage unique, la spécification en confie donc explicitement la garantie au serveur, et non au protocole.
Le résultat n’est pas une faille, c’est un niveau de garantie. Le transport offre au mieux un « au moins une fois ». L’exécution unique n’est pas une propriété que le réseau sait produire : elle se reconstruit plus haut, dans la couche qui connaît le sens de l’action.
Une discussion ouverte depuis septembre 2026 sur le dépôt de la spécification, encore active à la mi-novembre, décrit un cas reproduit de ce double effet et demande que le point soit au moins écrit noir sur blanc. À ce jour, aucun mécanisme normatif d’idempotence n’a été adopté, ni dans la révision publiée, ni dans celle en cours de rédaction. Une proposition en portait un : un champ facultatif attaché à l’appel d’outil, négocié entre le client et le serveur. Elle a été refermée le 23 août 2026, et le seul commentaire qui accompagne cette fermeture, signé d’un contributeur du dépôt, porte sur l’origine de la contribution et non sur le mécanisme proposé. Rien ne permet donc d’affirmer que le fond a été tranché, dans un sens ou dans l’autre.
Le secteur du paiement a réglé ce problème depuis longtemps
La réponse tient en une phrase : c’est le client qui fabrique une clé unique, et le serveur s’en sert pour reconnaître les reprises ultérieures de la même requête. Le rejeu n’est plus deviné, il est déclaré.
Stripe en donne la formulation la plus lisible. Un en-tête porte la clé. Sur la version 1 de l’API, la plateforme enregistre le code de statut et le corps de la première requête faite avec cette clé ; les reprises portant la même clé reçoivent cette réponse enregistrée, erreurs serveur comprises, au lieu de rejouer l’opération. La documentation suggère un UUID de version 4, limite la clé à 255 caractères, et indique que les clés peuvent être retirées du système passé vingt-quatre heures : une clé réutilisée après ce retrait produit une nouvelle requête.
Deux détails méritent d’être retenus parce qu’ils évitent des erreurs coûteuses. Toujours sur la version 1, la couche d’idempotence compare les paramètres entrants à ceux de la requête d’origine et renvoie une erreur s’ils diffèrent, ce qui empêche de recycler une clé pour une autre opération. La documentation déconseille par ailleurs de prendre pour clé une donnée sensible, une adresse de courriel par exemple.
Mettez maintenant les deux logiques côte à côte. Du côté du paiement, la reprise doit porter la même clé que la tentative initiale, sans quoi le mécanisme ne sert à rien. Du côté du protocole d’agent, la reprise doit porter un autreidentifiant. Les deux règles sont justes dans leur ordre respectif, et elles ne se rencontrent nulle part : l’identité qui circule dans le transport est celle du message, pas celle de l’intention.
Reste la question que cette comparaison rend inévitable. Chez Stripe, « le client » est votre code, qui sait ce qu’il veut faire et peut donc produire une clé stable. Dans une chaîne d’agents, qui tient ce rôle ? Le modèle, qui reformule son appel à chaque tentative et n’a aucune raison de régénérer la même valeur ? L’orchestrateur, qui voit passer un appel d’outil sans savoir à quelle intention métier il se rattache ? Tant que personne ne répond à cette question, la clé n’existe pas, et le rejeu se fait à l’aveugle.
Le bouton « Approuver » ne protège pas de la répétition
Un écran de validation répond à la question « faut-il que cela ait lieu ? ». Il ne répond jamais à « est-ce que cela a déjà eu lieu ? », et c’est la seconde qui décide d’un doublon.
C’est le point le plus contre-intuitif, parce que la validation humaine est précisément le garde-fou qu’on installe pour les actions à conséquence. Elle se place en amont de l’exécution. Une fois l’accord donné, la reprise technique qui suit n’est pas une nouvelle décision : personne ne redemande rien, et le second virement part avec la même autorisation que le premier. L’approbation couvre l’intention, pas le nombre d’exécutions.
Il y a pire, et c’est le cas le plus fréquent en exploitation. Un opérateur voit passer une erreur, ne sait pas si l’action a abouti, et reclique. Son geste est raisonnable : on lui a affiché un échec. Le système, lui, vient d’enregistrer deux intentions là où l’opérateur n’en avait qu’une. Concevoir un écran de validation demande déjà de composer avec la lassitude qu’installe une approbation demandée trop souvent. Il faut y ajouter une question qu’on oublie presque toujours : que montre l’écran quand le résultat est inconnu, et que se passe-t-il si l’humain tranche deux fois ?
Où poser la clé d’idempotence, et ce qui la rend inutile
La clé doit naître de l’intention métier, pas de l’appel technique. Une valeur tirée au sort au moment d’émettre la requête change à chaque tentative et ne déduplique rien. Une clé dérivée de ce que l’action veut accomplir, la facture à régler et l’opération demandée par exemple, reste identique quel que soit le nombre de tentatives, et c’est tout ce qu’on lui demande.
Trois pièges reviennent assez souvent pour valoir un avertissement. Le premier est le cache en mémoire du processus : il déduplique parfaitement tant qu’un seul processus tourne, et ne déduplique plus rien dès que le service redémarre ou se duplique derrière un répartiteur de charge, c’est-à-dire exactement dans les conditions où les reprises se produisent. Le second est la fenêtre de rétention : une clé oubliée trop tôt rouvre la porte, et le seuil de vingt-quatre heures retenu par Stripe donne un ordre de grandeur. Le troisième est la vérification des paramètres : sans elle, une clé réemployée pour une opération différente renvoie le résultat de la précédente, et l’on a remplacé un doublon par une réponse fausse.
Il faut enfin pouvoir constater le phénomène, car un doublon ne déclenche aucune alerte : les deux appels ont réussi, et seul celui qui le subit s’en aperçoit. La clé doit donc figurer dans les traces, à côté de l’identifiant de la requête, pour qu’on puisse compter les exécutions rattachées à une même intention. C’est une ligne de plus dans ce qu’il faut superviser sur un agent en production.
À retenir
Rien de ce qui précède n’est propre à l’intelligence artificielle. Les files de messages, les passerelles de paiement et les API bancaires vivent avec ce problème depuis des décennies, et elles l’ont résolu de la même façon : en faisant porter à la requête un identifiant d’intention que le serveur sait reconnaître. Ce que les agents changent, c’est le nombre d’endroits où le problème apparaît. Brancher un agent sur dix outils d’écriture, c’est ouvrir dix chemins vers un effet en double, souvent sans que personne ait eu à écrire la moindre ligne de code d’intégration.
La tentation sera de s’en remettre au modèle, en lui demandant dans ses instructions de ne pas répéter une action. C’est le seul endroit où il ne faut pas mettre la garantie. Un modèle peut reformuler, perdre le fil d’une conversation tronquée, ou être relancé par une couche d’orchestration qu’il ne contrôle pas, et aucune de ces reprises ne passe par son jugement. La protection doit se trouver là où l’effet se produit : du côté du service qui exécute.
La question à poser à votre équipe n’est donc pas « notre agent est-il fiable ? », à laquelle on répond toujours oui, mais « que se passe-t-il si cet appel part deux fois ? ». Posez-la outil par outil. Pour ceux qui lisent, la réponse est « à peu près rien ». Pour les autres, si personne ne sait répondre, vous venez de trouver le travail à faire avant la mise en production.



