Comment créer des agents et des systèmes d'agents pour des flux de travail

Guide technique et pratique pour concevoir, tester et mettre à l'échelle des agents et systèmes d'agents qui exécutent des flux de travail fiables en production.

Équipe Copy&Prompt · Publié août 2026 · Mis à jour août 2026

Réponse rapide

Les agents sont des composants logiciels autonomes qui utilisent des modèles de langage, des outils et un état pour accomplir des tâches. Construisez-les lorsque les tâches nécessitent de la planification, des appels d'outils ou un état de longue durée. Préférez des workflows orchestrés pour des pipelines déterministes. Ce guide présente une architecture d'agent reproductible, des prompts copiables, des tests et des conseils de montée en charge pour les développeurs.

Table des matières

1. Qu'est-ce qu'un agent et un système d'agents ?
2. Quand utiliser un agent ?
3. Architecture de base : composants et modèles
4. Étape par étape : construire un flux de travail agentique
5. Trois modèles de prompt copiables
6. Exemples appliqués
7. Agents vs workflows : comparaison
8. Erreurs courantes → pourquoi → correctif
9. Limitations et ce que les agents ne résolvent pas
10. Montée en charge, versioning et gouvernance
11. Comment vérifier le succès
12. Que faire en cas d'échec
13. Points clés à retenir
14. FAQ

Qu'est-ce qu'un agent et un système d'agents ?

Un agent est un composant logiciel qui agit de manière autonome avec un modèle, des outils et un état pour atteindre un objectif. Un système d'agents est un ou plusieurs agents qui se coordonnent pour accomplir un travail en plusieurs étapes. Les agents effectuent la planification, l'invocation d'outils, l'accès à la mémoire et la logique de décision au lieu d'un chemin de code fixe.

Concrètement, un agent : reçoit une entrée, raisonne (planification/chaîne de pensée), appelle des outils ou des API, met à jour l'état et renvoie des résultats. Les agents modernes utilisent fréquemment la génération augmentée par récupération (RAG) pour ancrer leurs décisions dans des sources de données externes.

Quand utiliser un agent ?

Utilisez un agent lorsque les tâches nécessitent une planification dynamique, un chaînage d'outils ou une interaction prolongée. Choisissez un workflow basé sur des règles lorsque les étapes sont fixes et que la déterminisme est important. Le compromis est flexibilité versus prévisibilité :

• Choisissez les agents pour les tâches ouvertes, la synthèse ou la coordination multi-outils.
• Choisissez les workflows pour l'ETL, les transformations répétables et les SLA stricts.

Pour un développeur technique, la question est pragmatique : le problème bénéficiera-t-il d'un modèle prenant des décisions de contrôle de flux ? Si oui, un agent peut réduire le code de liaison et le temps de développement mais augmenter l'effort de test et les besoins en observabilité.

Architecture de base : composants et modèles

Un système d'agents contient généralement ces composants. Chaque composant est une frontière d'intégration claire que vous pouvez tester et versionner indépendamment.

• Contrôleur (orchestrateur) : lance les exécutions, planifie les retries et applique les délais d'expiration.
• System prompt / politique : rôle + garde-fous qui façonnent le comportement de l'agent.
• Planificateur : produit un petit plan ou une liste d'étapes (1–6 sous-étapes).
• Exécuteur / lanceur d'outils : appelle des API, des bases de données ou des fonctions internes en utilisant des interfaces d'outil structurées.
• Mémoire / magasin de contexte : couche RAG ou base de vecteurs pour la récupération.
• Magasin d'état et journal d'événements : enregistrement durable des actions, entrées et sorties.
• Superviseur / couche de sécurité : vérifie les sorties par rapport aux règles et peut arrêter ou annuler.

Modèle : séparer le « penser » du « faire ». Le modèle raisonne dans un bac à sable sans effets secondaires. Seul le lanceur d'outils vérifié exécute les appels externes. Cela réduit les actions destructrices accidentelles et simplifie la lecture pour le débogage.

Étape par étape : construire un flux de travail agentique

Les 7 étapes suivantes constituent un plan de construction reproductible pour un agent de qualité production. Chaque étape est courte et testable.

1. Définissez l'objectif et les critères de réussite. Créez un banc d'essai explicite qui affirme les sorties observables et les effets secondaires.
2. Concevez les interfaces d'outils (contract-first). Chaque outil a un nom, des entrées, des sorties et des modes d'erreur. Implémentez un lanceur en sandbox pour les exécutions à blanc.
3. Rédigez le system prompt et le prompt du planificateur. Gardez-les modulaires. Le system prompt définit le rôle et les contraintes. Le prompt du planificateur demande un plan numéroté.
4. Ajoutez la récupération et l'ancrage. Attachez une couche RAG avec recherche vectorielle et citations pour chaque fait utilisé dans les décisions.
5. Implémentez l'exécuteur avec des portes de confirmation. L'exécuteur reçoit une action validée et doit confirmer les préconditions avant d'appeler des API externes.
6. Construisez des tableaux de bord d'observabilité et des alertes. Capturez les décisions, les appels d'outils, les latences et les raisons d'échec.
7. Testez avec des suites de chaos et de régression. Injectez des pannes d'outils, ou corrompez la mémoire, et vérifiez une récupération sûre.

Chaque étape ci-dessous inclut un bloc de prompt que vous pouvez coller dans un modèle. Ils suivent la norme Copy&Prompt : rôle, contexte, tâche, contraintes, format de sortie, annotation et estampille modèle.

Prompt du planificateur — produire un plan

Rôle : Agent planificateur qui divise un objectif utilisateur en au plus 6 étapes ordonnées.
Contexte : Vous avez lu la demande de l'utilisateur et avez accès à des faits fiables via la récupération.
Tâche : Retournez un plan numéroté (1-6) avec un outil estimé pour chaque étape.
Contraintes :
- N'utilisez pas plus de 6 étapes.
- Utilisez des phrases courtes et simples.
- Incluez un score de confiance 0-1 pour chaque étape.
Format de sortie :
- JSON array of { "step": int, "description": string, "tool": string, "confidence": number }

Pourquoi cela fonctionne : un JSON structuré rend l'analyse déterministe. Le score de confiance aide à rediriger vers un humain quand il est faible. Validé sur GPT-4 (OpenAI), juin 2026.

Prompt de l'exécuteur — appeler un outil en sécurité

Rôle : Agent exécuteur qui exécute une action approuvée contre une API.
Contexte : Vous avez reçu une seule étape du planificateur et un instantané des faits pertinents.
Tâche : Valider les préconditions, formater l'appel API et renvoyer un objet de confirmation.
Contraintes :
- N'appelez aucun outil si une précondition est manquante.
- Si des données manquent, renvoyez "needs_info" avec la liste des champs.
Format de sortie :
- JSON { "status": "ok|needs_info|error", "api_call": { "tool": string, "params": { ... } }, "notes": string }

Pourquoi cela fonctionne : l'exécuteur sépare la décision des effets secondaires. Il renvoie un objet api_call testable. Validé sur GPT-4 (OpenAI), juin 2026.

Prompt du superviseur — contrôles de sécurité

Rôle : Agent superviseur qui passe en revue l'api_call de l'exécuteur avant exécution.
Contexte : Vous avez l'objet api_call et un fichier de politique des actions interdites.
Tâche : Approuver ou rejeter l'api_call et fournir une raison courte.
Contraintes :
- Rejetez les appels correspondant à tout motif interdit.
- Approuvez uniquement si la confiance >= 0.65 sauf si l'action est en lecture seule.
Format de sortie :
- JSON { "approved": true|false, "reason": string }

Pourquoi cela fonctionne : un superviseur séparé garantit que les garde-fous sont appliqués automatiquement. Validé sur GPT-4 (OpenAI), juin 2026.

Trois modèles de prompt copiables

Plus haut nous avons fourni les prompts du planificateur, de l'exécuteur et du superviseur. Utilisez-les tels quels pour les exécutions de développement. Remplacez les [MAJUSCULES] seulement là où c'est indiqué. Ils sont autonomes et estampillés modèle.

Exemples appliqués : triage support et assistant de recherche

Triage support (multi-outil)

Objectif : trier les tickets de support entrants, exécuter des diagnostics et ouvrir un incident uniquement lorsqu'il est confirmé. Le planificateur crée des étapes : reproduire, collecter les logs, exécuter les diagnostics, proposer une remédiation. L'exécuteur n'ouvre des incidents qu'après approbation du superviseur.

Observation de notre équipe : en reproduisant ce modèle sur 10 flux support, les ouvertures d'incident erronées ont fortement diminué car le superviseur a empêché les écritures prématurées.

Assistant de recherche (RAG + outils)

Objectif : assembler une courte revue de littérature avec citations et un diaporama récapitulatif. L'agent planifie des recherches, récupère des sources, extrait les points clés et formate les diapositives. L'exécuteur appelle les outils de recherche et de génération de diapositives. Le superviseur applique les règles de citation.

Agents vs workflows : lequel choisir ?

Erreurs courantes → pourquoi → correctif

• Erreur : Laisser le modèle appeler directement des API externes.
  Pourquoi : Les effets secondaires sont difficiles à tester et peuvent être dangereux.
  Correctif : Utilisez un exécuteur qui renvoie un objet api_call ; un lanceur séparé exécute avec des journaux d'audit.
• Erreur : Pas d'étape de vérification du plan.
  Pourquoi : Les agents peuvent halluciner des séquences plausibles mais incorrectes.
  Correctif : Insérez un planificateur qui produit un plan numéroté et un score de confiance. Rejetez les plans à faible confiance ou demandez une revue humaine.
• Erreur : Stocker uniquement la sortie finale, pas la trace de décision.
  Pourquoi : Difficile de reproduire les échecs et de déboguer.
  Correctif : Persistez la sortie du planificateur, les recherches intermédiaires, les entrées d'outils et les réponses de l'exécuteur. Conservez des journaux d'événements immuables par exécution.

Limitations : ce que les systèmes d'agents ne résolvent pas

Les agents ne sont pas une solution miracle. Ils ne remplacent pas une validation rigoureuse des données, des garanties transactionnelles ou la fiabilité des systèmes externes. Les agents peuvent réduire l'effort de développement sur l'orchestration, mais ils augmentent le besoin en tests, observabilité et garde-fous.

De plus, les agents n'assurent pas l'exactitude des faits métiers sauf si vous les associez à une couche RAG et une vérification des sources. La RAG réduit les hallucinations mais ne les élimine pas.

Montée en charge, versioning et gouvernance

Pour monter un système d'agents à l'échelle, traitez les prompts et les politiques comme du code. Versionnez les prompts, testez les changements et déployez avec des runs en canari. Stockez chaque prompt et politique dans une bibliothèque récupérable afin que le texte exact ayant produit une décision puisse être retrouvé ultérieurement.

Copy&Prompt est une bibliothèque de prompts qui vous permet d'optimiser, stocker, partager et copier des prompts en un clic sur ChatGPT, Claude, Gemini, DeepSeek, Lovable et Midjourney.

Concrètement, appliquez ces pratiques :

• Versionnez les prompts avec des tags sémantiques et des journaux de modifications.
• Utilisez des sorties JSON validées par schéma pour les planificateurs et les exécuteurs.
• Enregistrez le modèle et la version de modèle utilisés pour chaque exécution. Horodatez les affirmations comportementales.
• Exécutez des tests unitaires contre un « modèle simulé » déterministe où les complétions renvoient des réponses préfabriquées pour les cas limites.

Comment vérifier qu'un agent fonctionne

Définissez les critères de réussite/échec dès le départ. Utilisez ces contrôles observables :

• Validité du plan : pourcentage de plans ne nécessitant aucune édition humaine.
• Taux de réussite des outils : ratio des réponses api_call.ok aux tentatives.
• Taux d'hallucination : échantillon de sorties vérifiées par rapport aux citations sources.
• Latence et coût : temps médian par exécution et consommation moyenne de tokens par appel modèle.

Que faire si cela ne fonctionne pas

Commencez par la reproductibilité. Rejouez exactement le planificateur, l'instantané de récupération et le prompt modèle. Si l'exécution diverge, testez chaque composant séparément :

1. Rejouez le planificateur avec le même contexte. Si le plan est instable, resserrez le system prompt et ajoutez des exemples (few-shot).
2. Rejouez les requêtes de récupération. Si les résultats varient, figez l'index vectoriel et stockez un instantané pour le test.
3. Exécutez l'exécuteur avec des réponses d'outils simulées. Si l'exécuteur omet des champs, ajustez les vérifications de préconditions.
4. Introduisez un superviseur qui rejette automatiquement les exécutions à faible confiance.

Questions fréquemment posées

Qu'est-ce qui distingue un agent d'un workflow classique piloté par API ?

Un agent décide des étapes suivantes à l'exécution en utilisant le raisonnement du modèle et la récupération. Un workflow suit un chemin fixe défini par le développeur. Les agents ajoutent planification et autonomie décisionnelle ; les workflows offrent prévisibilité et tests plus simples.

Comment empêcher un agent de boucler ou d'effectuer des actions nuisibles ?

Prévenez les boucles avec des limites d'étapes, du hachage d'itinéraires et des approbations du superviseur. Prévenez les actions nuisibles en séparant le « penser » du « faire » et en appliquant des contrôles de politique avant tout appel externe. Conservez un journal d'événements immuable pour permettre les retours en arrière.

Points clés à retenir

• Utilisez des agents lorsque les tâches nécessitent une planification dynamique, un chaînage d'outils ou un état de longue durée ; sinon préférez des workflows déterministes.
• Séparez planificateur, exécuteur et superviseur. Confinez les effets secondaires à la couche exécuteur.
• Versionnez les prompts comme du code, persistez les traces de décision et testez avec des outils simulés et des scénarios de chaos.
• Utilisez la RAG pour ancrer les faits et enregistrez toujours le nom du modèle et l'horodatage pour chaque décision.

Prochaine étape : choisissez une petite tâche dans votre produit, convertissez-la au modèle planificateur-exécuteur-superviseur, et lancez dix tests rejouables.

Une fois que vous avez une exécution d'agent reproductible, vous pouvez stocker, partager et itérer sur les prompts et les politiques pour l'usage de l'équipe.

Améliorez vos résultats IA dès aujourd'hui - Créez de meilleurs prompts et obtenez des réponses plus précises avec Copy&Prompt. Copy&Prompt →