# Comment construire un flux de travail multi-agents?

Date: 2026-03-10 · Author: Robert Scales · https://guidetoartificialintelligence.com/fr/apprendre/construire-flux-de-travail-multi-agents/

**Answer:** Découpez le travail en étapes qui ont chacune un seul objectif clair, confiez chaque étape à son propre agent avec des consignes étroites et un format de sortie fixe, et laissez votre code transmettre le résultat d’un agent au suivant. Commencez par une chaîne simple, comme recherche, rédaction et vérification, et n’ajoutez une boucle ou des agents en parallèle que lorsqu’un test montre que vous en avez besoin.

Un **flux de travail multi-agents** est un programme dans lequel plusieurs agents d’IA, chacun configuré pour une seule tâche, travaillent sur le même travail et se transmettent leurs résultats. Un **agent**, ici, est un modèle de langage doté de ses propres consignes et, souvent, de ses propres outils, comme la recherche Web. Au lieu de demander à un seul modèle de chercher, de rédiger et de réviser dans un long prompt unique, vous confiez chacune de ces tâches à un agent distinct et vous les reliez.

L’attrait, c’est la concentration. Un modèle qui a une seule tâche et des consignes courtes est plus facile à tester et à corriger qu’un modèle qui jongle avec cinq tâches à la fois. Le prix, c’est la coordination : quelqu’un doit décider quel agent s’exécute quand et ce que chacun reçoit. Ce « quelqu’un » peut être un autre modèle ou votre propre code, et ce choix compte plus que n’importe quel prompt.

## Deux façons de relier des agents

La documentation de l’Agents SDK d’OpenAI, une bibliothèque Python pour construire des agents, décrit deux styles d’**orchestration**, c’est-à-dire la logique qui décide quel agent s’exécute ensuite.

| Style | Qui décide de l’étape suivante | Convient à |
|---|---|---|
| Orchestration par le modèle | Un agent gestionnaire appelle d’autres agents comme des outils, ou cède la conversation à un spécialiste | Les tâches ouvertes dont le parcours est difficile à prévoir |
| Orchestration par le code | Votre programme exécute les agents dans un ordre fixe et vérifie leurs sorties | Les travaux répétables dont vous voulez un coût et une vitesse prévisibles |

La documentation note que les flux menés par le code sont plus prévisibles, et énumère des modèles comme l’enchaînement d’agents, où la sortie d’un agent devient l’entrée du suivant, et la boucle entre un agent qui travaille et un évaluateur jusqu’à ce que le travail soit accepté. Pour un premier projet multi-agents, commencez par le code. Vous voyez chaque passage de relais, et un bogue apparaît à un seul endroit.

L’équipe d’ingénierie d’Anthropic décrit le style mené par le modèle dans sa propre fonction Research : un agent principal planifie le travail et lance plusieurs sous-agents qui cherchent en parallèle, chacun avec sa propre fenêtre de contexte, puis font rapport. C’est puissant pour une recherche large, mais cela a aussi produit au début des erreurs comme le lancement de 50 sous-agents pour une question simple.

## Un exemple concret : chercher, rédiger, vérifier

L’objectif : à partir d’une courte commande, produire un article de 300 mots pour débutants dont chaque fait peut être relié à un lien. Trois agents se partagent le travail.

1. **Le chercheur** fait des recherches sur le Web et renvoie des faits, chacun avec son URL, sous forme de données structurées.
2. **Le rédacteur** transforme ces faits, et seulement ces faits, en brouillon.
3. **Le vérificateur** compare le brouillon aux faits et renvoie une approbation ou une liste de problèmes.

Votre code les exécute dans l’ordre. Si le vérificateur rejette le brouillon, le rédacteur reçoit les problèmes et réessaie, deux fois au plus. Après cela, une personne révise le texte.

```python
from pydantic import BaseModel
from agents import Agent, Runner, WebSearchTool

class Notes(BaseModel):
    facts: list[str]           # une phrase chacun, qui se termine par son URL
    open_questions: list[str]  # ce que le chercheur n’a pas pu confirmer

class Review(BaseModel):
    passed: bool
    problems: list[str]

researcher = Agent(
    name="Researcher", model="gpt-5.4",
    instructions=("Trouve de 5 à 8 faits qui répondent à la commande. Une phrase par fait, "
                  "qui se termine par l’URL où tu l’as trouvé. Mets plutôt tout ce qui "
                  "n’est pas confirmé dans open_questions."),
    tools=[WebSearchTool()], output_type=Notes)

writer = Agent(
    name="Writer", model="gpt-5.4",
    instructions=("Écris environ 300 mots pour des débutants en utilisant UNIQUEMENT les faits fournis. "
                  "Explique chaque terme technique. Garde chaque URL sous forme de lien."))

checker = Agent(
    name="Checker", model="gpt-5.4",
    instructions=("Compare le brouillon aux faits. Énumère chaque affirmation qui n’est pas "
                  "appuyée par un fait, chaque lien manquant et chaque terme non expliqué. "
                  "Mets passed à true seulement si la liste est vide."),
    output_type=Review)

def run_pipeline(brief, max_revisions=2):
    notes = Runner.run_sync(researcher, brief).final_output
    facts = "\n".join(notes.facts)
    draft = Runner.run_sync(writer, f"Commande : {brief}\n\nFaits :\n{facts}").final_output
    for attempt in range(max_revisions + 1):
        review = Runner.run_sync(checker, f"Faits :\n{facts}\n\nBrouillon :\n{draft}").final_output
        if review.passed:
            return draft
        if attempt < max_revisions:
            fixes = "\n".join(review.problems)
            draft = Runner.run_sync(writer, f"Faits :\n{facts}\n\nBrouillon :\n{draft}\n\n"
                                            f"Corrige seulement ces problèmes :\n{fixes}").final_output
    return "RÉVISION HUMAINE NÉCESSAIRE\n\n" + draft

print(run_pipeline("Explique ce qu’est une thermopompe et comment elle fonctionne en hiver."))
```

Trois détails rendent les passages de relais fiables. Le chercheur et le vérificateur utilisent `output_type` : ils renvoient donc des champs fixes que votre code peut lire, et non de la prose libre. Le rédacteur reçoit de nouveau les faits à chaque révision : il n’a jamais à s’en souvenir. Et `max_revisions` met fin à une dispute sans fin entre le rédacteur et le vérificateur.

> **À essayer :** lancez la chaîne avec une commande sur un sujet que vous connaissez bien. Retirez ensuite un fait des notes du chercheur avant que le rédacteur les voie, et regardez si le vérificateur repère une affirmation que le rédacteur ajoute pour combler le vide.

## Combien coûtent les flux de travail multi-agents?

Chaque appel d’agent est une requête distincte au modèle, et chacune transporte ses propres consignes et ses propres entrées. Anthropic rapporte que, dans ses données, les agents utilisaient environ quatre fois plus de jetons qu’une conversation ordinaire, et les systèmes multi-agents environ quinze fois plus. Un **jeton** est un petit morceau de texte, l’unité de facturation des API. Une chaîne de trois agents avec deux révisions fait jusqu’à six appels par article : consignez donc le nombre de jetons de chaque appel dès le premier jour.

Anthropic prévient aussi que les tâches dans lesquelles chaque agent a besoin du même contexte, ou dans lesquelles les agents dépendent fortement les uns des autres, comme la plupart des travaux de programmation, s’y prêtent moins bien. Les conceptions multi-agents brillent quand le travail se divise en parties indépendantes.

## Comment décider quel agent fait quoi?

Tracez la ligne là où une personne confierait le travail à un autre collègue. Chaque agent devrait être responsable d’un seul type de jugement : trouver l’information, rédiger ou vérifier. Si vous ne pouvez pas décrire la tâche d’un agent, son entrée et sa sortie en deux phrases, il en fait trop, ou la division n’est pas au bon endroit.

Ne donnez à chaque agent que les outils dont sa tâche a besoin. Dans l’exemple, seul le chercheur peut faire des recherches sur le Web; le rédacteur et le vérificateur travaillent uniquement à partir du texte qu’on leur fournit. Cela empêche le rédacteur de glisser des faits sans source et permet de rattacher facilement un problème à une seule étape.

Anthropic a constaté que chaque sous-agent a besoin que quatre choses soient précisées : un objectif, un format de sortie, des indications sur les outils et les sources à utiliser, et des limites claires à sa tâche. Des consignes vagues amenaient ses agents à répéter les recherches des autres ou à laisser des trous.

Enfin, testez chaque agent seul avant de les relier. Donnez au vérificateur un brouillon qui contient une erreur volontaire et confirmez qu’il le rejette. Quand chaque étape fonctionne seule, la chaîne fonctionne généralement aussi, et quand ce n’est pas le cas, vous savez quel maillon ouvrir.

## Sources

- Agent orchestration (OpenAI Agents SDK documentation): https://github.com/openai/openai-agents-python/blob/fc6afebc48d5526bdfa0aea9315cb039c61d58b5/docs/multi_agent.md
- How we built our multi-agent research system: https://www.anthropic.com/engineering/multi-agent-research-system