- Accueil
- Centre d'apprentissage
- Comment les agents IA s'intègrent-ils au cycle de vie logiciel ?
Comment les agents IA s'intègrent-ils au cycle de vie logiciel ?
Mis à jour le
Où les agents IA aident à planifier, développer, relire, tester, livrer et exploiter, comment les équipes multi-agents se répartissent le travail, et où un humain doit rester dans la boucle.
Sur cette page
Les agents IA s'intègrent au cycle de vie logiciel comme des exécutants au sein de chaque étape (planification, développement, revue, tests, livraison et exploitation), tandis que les personnes gardent les décisions qui engagent leur responsabilité : quoi construire, si un changement est assez bon pour être livré, et ce qui atteint la production. Le schéma qui fonctionne : des agents qui accomplissent des tâches bornées avec des outils limités, des vérifications indépendantes entre les étapes, et une personne qui approuve à des moments définis. Les agents accélèrent le travail ; ils ne suppriment pas le besoin des barrières qui l'entourent.
Ce qu'est un agent IA
Dans la livraison logicielle, un agent IA est un modèle de langage doté d'un objectif, d'un ensemble d'outils et d'une boucle. Il lit la tâche, choisit une action (ouvrir un fichier, chercher dans le code, écrire un changement, exécuter une commande), observe le résultat et choisit l'action suivante, jusqu'à ce qu'il estime l'objectif atteint ou qu'il se heurte à une limite.
C'est cette boucle qui distingue un agent d'un assistant. Une autocomplétion suggère les lignes suivantes. Un assistant conversationnel répond à une question. Un agent agit seul pendant de nombreuses étapes, et ce qu'il produit est un résultat plutôt qu'une suggestion : un plan, un diff, un rapport de test, une pull request.
Il en découle trois choses :
- Les agents ont besoin de limites. Le temps, les tokens, les fichiers et les outils qu'ils peuvent utiliser, et les actions qui nécessitent une personne.
- Les agents ont besoin de preuves, pas d'assurance. Un agent annoncera un succès qu'il n'a pas vérifié. Les résultats tels que les exécutions de tests doivent provenir d'une exécution réelle.
- Les agents ont besoin d'une trace. Quand un changement a été produit par une boucle d'appels au modèle, la seule façon de le comprendre plus tard est un enregistrement de ce qui a été demandé, de ce qui a été fait et de qui l'a approuvé.
Les agents IA tout au long du cycle de vie
Les agents peuvent aider à chaque étape. Ce qui change, c'est ce qu'ils produisent, et ce qu'une personne doit garder.
| Étape | Ce que les agents font bien | Ce que gardent les personnes |
|---|---|---|
| Planifier | Lire la base de code, rédiger les exigences, proposer des conceptions, rédiger des enregistrements de décision | Choisir quoi construire et accepter la conception |
| Développer | Écrire le changement, tests et documentation compris | La définition de la tâche et le périmètre du changement |
| Relire | Lire le diff à la recherche de bugs, de risques de sécurité et de tests manquants | Juger l'intention et la conception, trier les constats |
| Tester | Planifier les cas de test, écrire les tests, interpréter les échecs | Décider si un résultat ignoré ou instable est acceptable |
| Livrer | Vérifier que tout est prêt, résumer ce qui a changé, préparer les notes de version | Approuver la fusion et le déploiement en production |
| Exploiter | Trier les alertes, suggérer des causes racines, proposer un correctif | Déclarer et clore les incidents, communiquer avec les clients |
La colonne de droite n'est pas une liste de tâches que les agents ne peuvent pas tenter. C'est là qu'une décision exige quelqu'un qui puisse en être tenu responsable.
Agent unique ou développement multi-agents
Un agent généraliste unique peut planifier, écrire et tester un changement à lui seul. Le développement multi-agents répartit le travail entre des agents aux rôles et aux instructions différents, exécutés dans un ordre établi ou coordonnés par un autre agent.
| Aspect | Agent unique | Multi-agents |
|---|---|---|
| Structure | Une seule boucle fait tout | Des rôles tels que planificateur, développeur, relecteur, testeur |
| Vérification | L'agent juge son propre travail | La sortie d'un agent est relue par un autre |
| Contexte | Une seule fenêtre de contexte contient tout | Chaque rôle reçoit le contexte dont il a besoin |
| Coût | Plus faible par tâche | Plus élevé : davantage d'appels au modèle, contexte répété |
| Modes de défaillance | Les angles morts ne sont pas remis en cause | Erreurs de coordination ; des agents sur le même modèle peuvent s'accorder sur la même erreur |
| Traçabilité | Une seule longue transcription | Une étape par rôle, plus facile à auditer |
Les schémas multi-agents courants sont le pipeline (planifier, développer, relire, tester, dans l'ordre), les perspectives parallèles (plusieurs relecteurs examinent le même changement sous différents angles, puis l'un d'eux fusionne leurs constats) et le débat (deux agents proposent des approches et un troisième les critique). Exécuter les agents strictement l'un après l'autre est plus simple à appréhender, car chaque étape peut lire tout ce qui la précède.
La valeur d'agents supplémentaires vient de leur indépendance. Un relecteur qui utilise un prompt différent, voit le diff réel et n'a pas à défendre son propre travail a plus de chances de repérer des problèmes que l'auteur qui se relit lui-même.
Humain dans la boucle
« Humain dans la boucle » (human in the loop) signifie que le travail de l'agent ne prend effet qu'après l'approbation d'une personne. C'est différent de « l'humain en supervision » (human on the loop), où les agents agissent tandis qu'une personne surveille et peut intervenir, et de l'autonomie complète, où personne ne regarde.
Pour le code, ce sont les moments irréversibles ou à fort impact qui exigent une personne : la fusion dans la branche principale, le déploiement en production, la modification de l'infrastructure ou du contrôle d'accès, et tout ce qui envoie des données hors de l'organisation. Le reste peut être automatisé tant que les barrières sont en place.
Deux points pratiques déterminent si la revue humaine est réelle ou une simple formalité :
- Séparation des tâches. La personne qui a demandé un changement ne devrait pas en être la seule approbatrice lorsque quelqu'un d'autre peut le relire. Sinon, l'approbation revient à l'auteur qui se donne raison à lui-même.
- L'approbateur a besoin de preuves. Un diff, les résultats de tests, les constats de revue ouverts et les décisions de politique, au même endroit. Demander à une personne d'approuver un changement volumineux sans contexte produit des approbations de pure forme.
La lassitude des approbations est un risque réel. Si chaque changement trivial exige une personne, les gens approuvent sans lire. Utilisez des politiques pour décider quels changements méritent une attention particulière, et laissez les barrières automatisées gérer le reste.
DevOps agentique
Le DevOps agentique désigne l'utilisation d'agents dans le travail de livraison et d'exploitation : modifier les pipelines et le code d'infrastructure, mettre à niveau les dépendances, trier les incidents et proposer des correctifs. Ces tâches touchent des systèmes dont la portée dépasse celle d'un changement applicatif, si bien que les contrôles comptent davantage :
- Moindre privilège. Un agent ne reçoit que les outils et les chemins dont sa tâche a besoin. Les identifiants restent dans les jobs de build, pas dans le contexte de l'agent.
- Isolation. Le code écrit par un agent s'exécute dans un bac à sable, pas sur un serveur partagé ni sur le portable d'un développeur.
- Policy as code. Des règles décident de ce que les agents peuvent faire seuls, de ce qui nécessite une approbation et de ce qui est interdit, par exemple tout changement sous
infra/**. - Les mêmes barrières. Un changement de pipeline écrit par un agent passe par les tests, la revue et l'approbation comme n'importe quel autre changement.
- Métriques de résultat. Des mesures de livraison telles que la fréquence de déploiement, le délai de livraison des changements, le taux d'échec des changements et le temps de rétablissement vous disent si les agents aident, mieux que le nombre de lignes écrites.
Comment introduire des agents IA dans votre processus de livraison
- Commencez par des tâches bornées. Choisissez un travail avec une définition claire de « terminé » et de bons tests, comme de petites fonctionnalités, des corrections de bugs avec une reproduction ou des mises à niveau de dépendances.
- Définissez les rôles. Décidez quels agents planifient, développent, relisent et testent, et ce que chacun peut lire et utiliser.
- Mettez des barrières entre les étapes. Des tests sur le changement exact, une revue du diff réel et un seuil de gravité bloquant. Voir Qu'est-ce qu'une barrière qualité ?
- Placez les approbations humaines. Au minimum avant la fusion, et avant la production pour tout ce qui est risqué. Séparez l'auteur et l'approbateur lorsque l'équipe le permet.
- Rédigez la politique. Quels workflows peuvent démarrer sans approbation, quels chemins exigent une revue, quels outils et quels déploiements sont interdits.
- Plafonnez le temps et les dépenses. Les agents bouclent. Fixez des limites par exécution et par période. Voir Combien coûte le codage par IA ?
- Gardez une trace. Pour chaque changement : la tâche, les agents et les modèles, les constats, les tests, les approbations et la livraison.
- Mesurez les résultats. Comparez le délai de livraison et le taux d'échec des changements avant et après, et n'élargissez le périmètre que lorsque les chiffres le justifient.
Comment AI CodeOps s'y prend
AI CodeOps exécute des agents IA tout au long du cycle de vie, dans le navigateur. Chaque session exécute l'un des 16 workflows intégrés, chacun étant une liste fixe d'étapes exécutées l'une après l'autre par des agents tels que l'Architect, le Builder, le Reviewer et le Tester. Le workflow par défaut, Plan, Build, Review & Test, exécute ces quatre agents dans l'ordre ; d'autres couvrent les changements sensibles pour la sécurité, la préparation des livraisons, l'actualisation des dépendances et la réponse aux incidents. Chaque étape voit ce qu'ont écrit les étapes précédentes. Les workflows étiquetés parallel, debate ou swarm décrivent la façon dont les étapes se répartissent le travail, et non le fait qu'elles s'exécutent en même temps.
Après l'étape qui implémente le changement, le changement est écrit sur une copie neuve du dépôt et vos propres tests s'exécutent dans un bac à sable hors ligne. Les étapes qui vérifient le travail, comme Review et Test, s'exécutent ensuite, sur le changement écrit et le résultat de test enregistré. Une revue distincte lit ensuite le diff et enregistre des constats. Puis une personne approuve. La personne qui a lancé la session ne peut pas donner le vote d'approbation tant que quelqu'un d'autre dans l'espace de travail peut approuver ; un espace de travail d'une seule personne peut approuver son propre changement. Ce n'est qu'alors que la pull request s'ouvre.
Une politique de l'espace de travail décide de ce que les sessions peuvent faire sans une personne. Cet exemple retient les mises à niveau de dépendances pour approbation avant leur démarrage, exige une revue des changements d'infrastructure, bloque les déploiements automatiques en production et tient un outil MCP hors de portée des agents :
[
{
"id": "approve-dependency-refresh",
"action": "workflow.dispatch",
"resource": "dependency-refresh",
"decision": "ask",
"description": "A person approves before a dependency upgrade session starts"
},
{ "id": "review-infra-changes", "action": "diff.apply", "resource": "infra/**", "decision": "ask" },
{ "id": "no-production-deploys", "action": "release.deploy", "resource": "production", "decision": "deny" },
{ "id": "no-repo-deletes", "action": "mcp.invoke", "resource": "github/delete_*", "decision": "deny" }
]
La règle correspondante la plus stricte l'emporte, et toute décision autre qu'une simple autorisation est enregistrée. Chaque changement peut être téléchargé sous forme de dossier de preuves signé qui liste la tâche, les modèles, les étapes, les constats, les tests, les approbations et la livraison.
Consultez Planification par IA pour l'étape de planification, Workflows pour chaque workflow intégré, Comment fonctionne AI CodeOps pour une session de bout en bout, et Approbations et politiques pour les règles.
Pour aller plus loin
- Où placer les approbations humaines dans un workflow de codage par IA : quelles décisions exigent une personne, la séparation des tâches quand un agent écrit le code, et comment éviter la lassitude des approbations.
- Schémas multi-agents pour la livraison logicielle : pipelines, revues parallèles, débat, orchestrateurs et boucles de vérification, et la façon dont chacun échoue.
Questions fréquentes
Quelle est la différence entre un assistant de codage IA et un agent IA ?
Un assistant répond ou complète du code quand vous le lui demandez. Un agent reçoit un objectif et y travaille en boucle, en choisissant des actions telles que lire des fichiers, modifier du code ou exécuter des outils, jusqu'à ce qu'il décide qu'il a terminé.
Qu'est-ce que le développement multi-agents ?
Répartir une tâche entre plusieurs agents aux rôles différents, par exemple un planificateur, un développeur, un relecteur et un testeur, chacun avec ses propres instructions, afin de diviser le travail et que la sortie d'un agent soit vérifiée par un autre.
Que signifie « humain dans la boucle » pour le codage par IA ?
Une personne doit approuver à des moments définis avant que le travail de l'agent prenne effet, généralement avant qu'un changement soit fusionné ou déployé. L'agent propose ; une personne décide.
Qu'est-ce que le DevOps agentique ?
L'utilisation d'agents IA dans le travail de livraison et d'exploitation, comme les changements de pipeline, les mises à niveau de dépendances et la réponse aux incidents, sous les mêmes contrôles que les changements humains : moindre privilège, barrières, approbations et piste d'audit.
Plus d'agents donnent-ils de meilleurs résultats ?
Pas automatiquement. Des agents supplémentaires ajoutent du coût et de la coordination, et des agents fondés sur le même modèle peuvent commettre les mêmes erreurs. Ajoutez un rôle lorsqu'il vérifie quelque chose que les autres ne vérifient pas.