Gérer les tickets d'agents IA : critères et relecture

Si la personne qui demande une pull request à un agent IA est aussi celle qui l'approuve, cette approbation ne compte pas : les règles de GitHub le disent, et Atipol applique la même séparation dans son flux de tickets. Chaque ticket exige aussi des critères d'acceptation écrits avant le lancement de l'agent, plus un historique de décisions journalisé et consultable, pour vérifier la livraison contre une cible fixée à l'avance, pas après coup.
Les agents livrent vite, mais personne ne peut dire ce qui a été approuvé
Un CTO qui confie du travail à des agents IA obtient en général un résultat rapidement. La question la plus difficile vient après : qu'est-ce que l'agent a exactement reçu comme consigne, qui a vérifié la livraison par rapport à cette demande, et qui a validé avant l'intégration ou la mise en production. Sans un ticket qui enregistre une cible, un relecteur et une décision, la rapidité crée une trace que personne ne peut suivre six semaines plus tard quand quelque chose casse.
C'est un manque de processus, pas un problème de qualité du modèle. Un agent rapide qui travaille à partir d'un brief non écrit et validé sans examen par la personne même qui l'a demandé produit un résultat aussi vite qu'un agent qui travaille à partir d'un ticket clair. La différence n'apparaît que lors d'une revue d'incident, d'un audit, ou d'un désaccord sur ce qui avait réellement été promis.
Ce coût a tendance à apparaître au pire moment : pendant l'analyse d'un incident, une revue de sécurité, ou un audit client, quand quelqu'un demande la trace de ce qui a été demandé à l'agent et de qui l'a approuvé, et que la réponse honnête est qu'aucune trace de ce genre n'existe. Le NIST AI Risk Management Framework (AI RMF 1.0, publié le 26 janvier 2023) présente cela comme un enjeu de cycle de vie plutôt qu'une tâche ponctuelle : le cadre est destiné à un usage volontaire pour aider les organisations à intégrer des considérations de confiance dans la conception, le développement, l'usage et l'évaluation des systèmes d'IA, pas seulement dans le résultat d'une seule exécution d'agent.
Écrire les critères d'acceptation avant que l'agent démarre, pas après
Un critère d'acceptation fixe, par écrit, ce qu'une livraison doit satisfaire avant le lancement de l'agent. Fixer la barre après coup, une fois que le propre résumé de l'agent sur son travail est déjà sur la table, incite à noter le travail par rapport à ce qui a été livré plutôt que par rapport à ce qui avait été demandé. La règle est claire ici : chaque ticket exige des critères d'acceptation écrits avant le lancement de l'agent, et un critère que l'agent ne peut pas satisfaire doit remonter comme un blocage avant la relecture, pas pendant.
Un second élément accompagne les critères : le périmètre de fichiers. Réserver quels fichiers ou zones un ticket peut toucher avant que l'agent démarre signifie que deux tickets en cours ne peuvent pas revendiquer le même périmètre, si bien qu'un chevauchement entre deux agents est détecté à la prise en charge plutôt que découvert au milieu d'un conflit de fusion.
En pratique, cela signifie que les critères décrivent un résultat, pas une implémentation : à quel fichier ou module le changement s'applique, ce que le diff doit et ne doit pas toucher, et le contrôle précis qui doit passer. Un critère que l'agent ne peut pas satisfaire est censé remonter comme un blocage et revenir au demandeur avant même qu'un relecteur n'ouvre la pull request, plutôt que d'être découvert pendant la relecture une fois le travail déjà fait.
Le cycle de vie d'un ticket confié à un agent IA
La documentation propre de GitHub pour son agent de code Copilot décrit une version concrète de ce cycle de vie. Une fois qu'une issue est assignée à l'agent, celui-ci accuse réception de l'assignation par une réaction, ouvre une branche dédiée et une pull request en brouillon liée à l'issue, et démarre une session d'agent. Pendant son travail, il pousse des commits et met à jour le corps de la pull request avec des messages de statut. Une fois terminé, il poste un événement de fin de travail et demande une relecture, ce qui est le signal que le ticket est passé d'en cours à en attente d'une décision humaine.
La même documentation ajoute un détail de dépannage qui compte sur le plan opérationnel : les sessions expirent après une heure, et un agent bloqué se récupère en désassignant puis réassignant l'issue, ou en republiant le commentaire déclencheur, pas en attendant indéfiniment.
La documentation de GitHub décrit plusieurs façons de présenter un ticket à l'agent : assigner une issue depuis l'onglet Issues de la même façon qu'on l'assignerait à un coéquipier, depuis GitHub Projects ou GitHub Mobile, via l'API GraphQL en vérifiant que l'agent de code apparaît comme acteur suggéré puis en appelant une mutation pour l'assigner, ou en ligne de commande avec le GitHub CLI. Quel que soit le chemin utilisé, l'agent ne reçoit que le titre de l'issue, sa description, et les commentaires qui existaient au moment de l'assignation ; les commentaires ajoutés ensuite ne sont pas vus par l'agent, donc les instructions ultérieures doivent aller sur la pull request elle-même, pas revenir sur l'issue d'origine.
Les étapes en un coup d'œil
Les étapes ci-dessous généralisent à travers les outils qui assignent des tickets à des agents IA ; les noms des signaux diffèrent selon la plateforme, mais pas la séquence.
Nommer le signal à chaque étape compte plus qu'il n'y paraît : une équipe qui sait seulement qu'un agent est assigné, sans signal visible pour l'accusé de réception, le travail en cours ou la fin, finit par interroger l'agent au lieu d'être prévenue quand un ticket demande de l'attention.
| Étape | Signal à surveiller | Qui agit ensuite |
|---|---|---|
| Assignation | L'agent accuse réception du ticket | L'agent démarre le travail dans son périmètre réservé |
| En cours | Des mises à jour de statut et des commits arrivent sur la branche du ticket | L'équipe peut commenter pour réorienter avant la fin |
| Travail terminé | L'agent poste un événement de fin | Un relecteur autre que le demandeur est sollicité |
| Relecture | Le relecteur vérifie le diff par rapport aux critères d'acceptation | Le relecteur approuve ou renvoie avec un blocage |
| Intégration | Les contrôles sont relancés au moment de la fusion | La décision et le ticket sont enregistrés dans l'historique |
La personne qui a demandé le travail ne devrait pas être celle qui l'approuve
La documentation de GitHub sur la relecture d'une pull request créée par Copilot indique que si un dépôt exige des approbations de pull request, l'approbation de la personne qui a assigné l'issue à l'agent ne compte pas dans ce nombre requis ; un autre relecteur doit l'approuver avant la fusion. Le support de formation associé est plus direct sur le pourquoi : le développeur qui a demandé à Copilot de créer la pull request ne peut pas l'approuver, ce qui préserve la règle de relecture obligatoire du dépôt et maintient un contrôle indépendant dans la boucle.
Atipol applique la même séparation dans son propre flux de tickets : l'agent lead du projet relit chaque livraison avant de l'intégrer, et cette relecture est censée couvrir le diff réel, pas seulement le résumé que l'agent donne de son propre travail. L'intégration relance ensuite les contrôles du projet plutôt que de se reposer uniquement sur la relecture qui l'a précédée, afin qu'un contrôle qui aurait détecté un problème ne soit pas sauté parce qu'un humain a déjà regardé le résumé.
Ce n'est pas une exception propre à Copilot. La documentation générale de GitHub sur les relectures obligatoires indique clairement que les auteurs d'une pull request ne peuvent pas approuver leur propre pull request, et que lorsqu'un jeu de règles ou une règle de protection de branche exige des relectures, une approbation doit venir de quelqu'un d'autre que l'auteur avant que le changement puisse être fusionné. La même page ajoute deux détails propres à Copilot : les approbations de Copilot lui-même apparaissent dans ce panneau de relecteurs mais ne comptent pas dans le nombre requis, et la personne qui a assigné l'issue associée à Copilot ne peut pas approuver la pull request qu'il a soulevée, ce qui ferme la faille consistant à approuver indirectement via l'agent.
La séparation des rôles, de l'assignation à l'intégration, sous forme de schéma :
Transformer les décisions de ticket en un historique consultable plus tard
L'approbation d'un relecteur n'est utile que tant que quelqu'un se souvient qu'elle a eu lieu. Atipol conserve l'historique de chaque ticket et des décisions de relecture qui l'ont validé, produisant une trace de qui a demandé quoi et qui a approuvé quoi avant qu'une action soit intégrée. Chaque appel que fait un agent est relié à un agent, un ticket et un résultat, ainsi qu'à toute approbation accordée ou refusée, ce qui transforme une question posée des semaines plus tard en quelque chose qu'un relecteur peut rechercher plutôt qu'en quelque chose qu'un relecteur doit se rappeler.
Un journal mis en place après un incident n'aide pas à établir ce qui a réellement été lu ou écrit pendant celui-ci ; la trace doit exister avant que l'agent soit connecté, pas après qu'un problème survienne.
Le raisonnement qui pousse à construire ce journal avant de connecter un agent, plutôt que de l'ajouter après qu'un problème survient, est le même que celui qui pousse à écrire les critères d'acceptation avant le lancement : une trace assemblée après coup peut décrire ce qui s'est probablement passé, mais elle ne peut pas remplacer une ligne qui relie un appel précis à l'agent qui l'a fait, au ticket sur lequel il travaillait, et à l'approbation accordée ou refusée à ce moment-là.
Quand le flux natif d'une plateforme reste le bon choix
Les équipes dont le travail des agents IA se déroule entièrement dans un seul dépôt GitHub, avec un seul agent de code et une règle de protection de branche déjà en place, obtiennent l'assignation, la pull request en brouillon, l'événement de fin de travail et la règle d'approbation indépendante directement de GitHub, comme décrit plus haut, sans ajouter un autre système. Ce flux natif suffit quand les critères d'acceptation vivent dans la description de l'issue et que les règles de relecture d'une seule plateforme sont les seules qui comptent.
Le manque apparaît dès qu'une équipe fait tourner plus d'un agent, ou plus d'un outil, sur un backlog partagé : le périmètre de fichiers doit être réservé à travers les outils, les critères d'acceptation doivent être visibles pour quel que soit l'agent qui reprend le ticket ensuite, et l'historique des décisions doit couvrir des agents qui ne touchent jamais au flux de pull request de GitHub. Cette coordination entre outils et agents est ce qu'un système de tickets conçu pour les agents IA, comme celui d'Atipol, est censé couvrir ; voir comment plusieurs agents partagent des tickets et un périmètre de fichiers sans se percuter sur atipol.ai/agentic-ai-blog/parallel-claude-code-agents.
La même documentation GitHub liste elle-même les limites de ce flux natif : l'agent n'est pas disponible sur les dépôts personnels Enterprise Managed User, qui doivent donc migrer vers un dépôt appartenant à une organisation avec des runners hébergés par GitHub ; une session qui semble bloquée peut généralement être récupérée en désassignant puis réassignant l'issue plutôt qu'en attendant, puisque les sessions expirent après une heure ; et les pull requests de l'agent restent en brouillon et ne déclenchent pas automatiquement GitHub Actions, donc un humain doit encore approuver et lancer le workflow à la main. Rien de tout cela ne change quand un second agent ou un second outil rejoint le même backlog ; cela signifie simplement que le flux natif n'a jamais été conçu pour en coordonner plus d'un.
Ancrer cette pratique dans une équipe
Rien de tout cela n'exige de nouvel outillage pour démarrer : un ticket avec des critères d'acceptation écrits, un relecteur qui n'a pas demandé le travail, et une trace de la décision couvrent la majeure partie du manque décrit plus haut. Le cadre de gouvernance derrière cette pratique, avec un exemple de politique d'usage et où la relecture humaine doit se situer avant une fusion, est détaillé sur atipol.ai/agentic-ai-blog/ai-agent-governance.
Une version minimale de cette pratique tient sur un seul ticket : un critère d'acceptation écrit, un relecteur nommé qui n'était pas le demandeur, et une ligne dans un journal enregistrant la décision. Tout le reste décrit plus haut, règles de protection de branche, assignation pilotée par API, piste d'audit dédiée, est une façon d'appliquer cette version minimale à plus grande échelle dès que plusieurs agents et plusieurs relecteurs sont impliqués.
Pour voir ce flux de ticket, de relecture et d'historique appliqué de bout en bout sur une équipe d'agents, la visite guidée sur atipol.ai/tour montre comment assigner un ticket à un agent lead, fixer des critères d'acceptation, et relire une livraison avant qu'elle soit intégrée.
Des critères d'acceptation écrits avant le lancement de l'agent, un relecteur qui n'a pas demandé le travail, et une décision journalisée qui existe avant que l'agent soit connecté.
Questions fréquentes
Qui devrait écrire les critères d'acceptation d'un ticket d'agent IA ?
Celui qui demande le travail écrit les critères avant le lancement de l'agent, car l'objectif est une cible par rapport à laquelle l'agent peut être vérifié, pas un résumé noté après la livraison.
L'agent qui a terminé un ticket peut-il approuver sa propre pull request ?
Non. Selon la documentation de GitHub sur l'agent de code Copilot et sur les relectures obligatoires en général, une approbation de la personne qui a assigné l'issue ne compte pas dans les relectures obligatoires d'un dépôt, et un relecteur différent doit approuver le changement avant la fusion.
Que doit enregistrer un journal d'audit pour les tickets d'agents IA ?
Chaque entrée doit relier un agent, un ticket et un résultat, ainsi que toute approbation accordée ou refusée, et elle doit exister avant que l'agent soit connecté afin de pouvoir répondre à des questions soulevées après coup.
Sources
- Microsoft Learn, Assigning, tracking, and troubleshooting Copilot in the cloud, mise à jour 27/10/2026
- GitHub Docs, Reviewing a pull request created by Copilot, consultée le 11/11/2026
- GitHub Docs, Approving a pull request with required reviews, consultée le 11/11/2026
- NIST, AI Risk Management Framework (AI RMF 1.0), publié le 26/01/2023
La démo publique montre une organisation fictive en fonctionnement, sans compte. L'offre gratuite donne un projet, trois agents et un agent lead.
