---
title: "Le cycle de vie du développement d'agents IA : étapes, évals et garde-fous"
description: "Le cycle de vie des agents IA en six étapes : définir la tâche, choisir modèle et outils, construire, évaluer, déployer avec garde-fous, surveiller."
canonical: https://automo.build/fr/learn/agent-development-lifecycle
last-updated: 2026-11-19
---
# Le cycle de vie du développement d'agents IA : étapes, évals et garde-fous

Construire un agent IA ne ressemble pas à la livraison d'une fonctionnalité ordinaire. La sortie est probabiliste, les outils ont des effets réels, et la qualité se mesure avec des évals, pas seulement des tests. Voici le cycle de vie qui tient en production.

Le cycle de vie du développement d'agents IA est le processus pour construire, livrer et exploiter des agents IA : définir la tâche et les critères de réussite, choisir le modèle et les outils, construire prompts, outils et mémoire, évaluer avec des évals hors ligne et du red teaming, déployer avec des garde-fous et une approbation humaine, puis surveiller et itérer. Il diffère du SDLC classique parce que le comportement d'un agent est probabiliste : évals et garde-fous à l'exécution remplacent une grande partie de ce que garantissaient les tests figés.

## Ce qui rend le cycle de vie d'un agent différent

Cette page parle de la construction des agents eux-mêmes : agents de support, copilotes internes, agents de recherche ou d'opérations qui appellent des outils pour le compte de quelqu'un. Si vous voulez savoir comment l'IA change le cycle de vie d'un logiciel ordinaire, lisez [L'IA dans le SDLC](/learn/ai-in-the-sdlc). Pour la définition d'un cycle de vie piloté par des agents, voyez [Qu'est-ce qu'un SDLC IA](/learn/what-is-an-ai-sdlc).

Trois faits distinguent le travail sur les agents. La même entrée peut produire des sorties différentes, donc une exécution réussie ne prouve pas grand-chose. Les agents agissent via des outils, donc une mauvaise réponse peut devenir une mauvaise action : un remboursement émis, un enregistrement supprimé, un e-mail envoyé. Et la qualité dérive après le lancement, car les modèles, les prompts, les données et les usages changent. Le cycle de vie ci-dessous est construit autour de ces trois faits.

## Les six étapes du cycle de vie d'un agent

La première fois, les étapes se suivent dans l'ordre ; ensuite elles tournent en boucle. Chaque échec en production devient un nouveau cas d'éval, et chaque changement d'évals renvoie l'agent dans les étapes quatre à six.

1. **Définir la tâche et les critères de réussite** Écrivez la tâche, les utilisateurs, ce que l'agent peut faire ou non, et comment vous saurez qu'il fonctionne : taux de réussite visé, types d'erreurs acceptables, latence et coût par tâche. Rassemblez dès maintenant 30 à 100 exemples réels. Ils deviennent votre premier jeu d'évals.
2. **Choisir le modèle et les outils** Prenez le plus petit modèle qui atteint la barre sur vos exemples, et le minimum d'outils dont la tâche a besoin. Chaque outil est une permission. Commencez en lecture seule ; tout ce qui écrit, paie ou envoie reçoit un périmètre étroit.
3. **Construire prompts, outils et mémoire** Écrivez le prompt système et les descriptions d'outils, ajoutez de la recherche documentaire ou de la mémoire seulement là où la tâche a besoin de contexte, et versionnez le tout comme du code. Un changement de prompt est un changement de code et mérite revue et historique.
4. **Évaluer avec des évals hors ligne et du red teaming** Faites tourner l'agent sur le jeu d'évals à chaque changement et notez la réussite des tâches, la justesse des appels d'outils, la sécurité et le coût. Ajoutez des cas adverses comme l'injection de prompt, les demandes hors périmètre et les tentatives d'exfiltration de données. Un changement qui fait baisser le score n'est pas livré.
5. **Déployer avec garde-fous et approbation humaine** Publiez derrière des filtres d'entrée et de sortie, des limites de débit et de dépense, et des identifiants à périmètre restreint. Exigez une approbation humaine pour les actions irréversibles ou coûteuses jusqu'à ce que les évals et les données de production justifient plus d'autonomie. Commencez avec une petite part du trafic.
6. **Surveiller et itérer** Journalisez chaque exécution avec ses appels d'outils, relisez un échantillon de conversations, suivez coût, latence et taux d'escalade, et transformez les vrais échecs en nouveaux cas d'éval. Le jeu d'évals devrait grossir chaque semaine où l'agent est en ligne.

## Le cycle de vie d'un agent en un coup d'œil

| Étape | Livrable clé | Point de contrôle humain | Risque principal |
| --- | --- | --- | --- |
| Définir | Spécification de la tâche, métriques, premiers exemples | Validation du périmètre et des limites | Des objectifs flous que personne ne peut tester |
| Modèle et outils | Choix du modèle, liste d'outils avec périmètres | Approbation de chaque permission d'écriture | Des outils trop puissants |
| Construire | Prompts, outils et mémoire versionnés | Revue des changements de prompts et d'outils | Des modifications de prompt non tracées |
| Évaluer | Scores d'évals et résultats du red teaming | Décision sur la barre de livraison | Livrer après quelques belles démos |
| Déployer | Garde-fous, limites et points d'approbation | Approbation des actions à risque | Des actions irréversibles sans contrôle |
| Surveiller | Traces, données de coût, nouveaux cas d'éval | Revue hebdomadaire des échecs | Une dérive silencieuse de la qualité |

## Les évals et les garde-fous forment la colonne vertébrale

Dans un SDLC classique, les tests vous disent si le code fait ce qu'il doit. Pour les agents, ce rôle revient aux évals, qui notent des distributions plutôt que des réponses isolées. Gardez trois types de jeux : un jeu de régression fait de tâches réelles, un jeu adverse pour le red teaming et un petit jeu de référence relu par un expert métier. Exécutez-les à chaque changement de prompt, de modèle ou d'outil, comme la CI lance les tests à chaque commit.

Les garde-fous couvrent ce que les évals ne peuvent pas prévoir. Ils agissent à l'exécution : ce que l'agent peut appeler, combien il peut dépenser, quelles actions attendent un humain. L'agent qui prépare un remboursement ne devrait pas être celui qui l'approuve. Cette séparation des tâches est le même principe qui, dans un SDLC IA gouverné, place la revue humaine devant le merge.

## La place d'Automo Build

La plupart des agents sont livrés comme une fonctionnalité dans une app : un assistant de support dans un portail client, un agent d'approbation dans un outil interne. Avec Automo Build, vous construisez cette app, fonctionnalités IA comprises, à partir d'un prompt, pendant que les agents de la plateforme écrivent et testent le code et que des agents relecteurs et [Guardrails](/platform/guardrails) vérifient chaque changement avant le merge. L'agent que vous livrez suit le même chemin relu vers la production que le reste de l'app.

## FAQ

**Qu'est-ce que le cycle de vie du développement d'agents IA ?**

C'est le processus pour construire et exploiter des agents IA : définir la tâche et les critères de réussite, choisir le modèle et les outils, construire prompts, outils et mémoire, évaluer, déployer avec garde-fous et approbation humaine, puis surveiller et itérer.

**En quoi diffère-t-il du SDLC ?**

Les phases se ressemblent, mais le comportement d'un agent est probabiliste et l'agent agit via des outils. Les évals, le red teaming, les garde-fous à l'exécution et la surveillance en production deviennent donc centraux, là où un SDLC classique repose surtout sur des tests déterministes.

**Que sont les évals d'un agent ?**

Des jeux de tests reproductibles qui notent les sorties et les appels d'outils d'un agent sur des tâches réelles et adverses. Elles conditionnent les livraisons comme les tests unitaires conditionnent les changements de code, et elles s'enrichissent à mesure que la production révèle de nouveaux échecs.

**Quand un agent IA a-t-il besoin d'une approbation humaine ?**

Pour les actions irréversibles, coûteuses ou visibles des clients : paiements, suppressions, messages sortants, changements de droits. Gardez l'approbation sur ces actions jusqu'à ce que les évals et les données de production montrent que l'agent les gère de façon fiable, puis assouplissez-la type d'action par type d'action.

## Related

- [L'IA dans le SDLC](https://automo.build/learn/ai-in-the-sdlc)
- [Qu'est-ce qu'un SDLC IA ?](https://automo.build/learn/what-is-an-ai-sdlc)
- [Fonctionnalités IA](https://automo.build/platform/ai-features)
- [Guardrails](https://automo.build/platform/guardrails)
- [Assistants IA](https://automo.build/use-cases/ai-assistants)
- [Automo vs Claude Code](https://automo.build/compare/claude-code)
- [Tarifs](https://automo.build/pricing)

Canonical page: https://automo.build/fr/learn/agent-development-lifecycle
Site overview for agents: https://automo.build/llms.txt
