0Pricing
AI Engineering Academy · Leçon

Modèle orchestrateur-sous-agent

Implémentez le modèle orchestrateur-sous-agent : un agent planificateur décompose les tâches en sous-tâches, les délègue à des agents spécialisés, puis synthétise leurs résultats en une sortie finale.

Modèle orchestrateur-sous-agent est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.

Le modèle mental orchestrator-subagent

Le modèle orchestrator-subagent est l’architecture multi-agent la plus utilisée. Un agent orchestrator reçoit un objectif de haut niveau, le décompose en sous-tâches, délègue chaque sous-tâche à un subagent spécialisé, rassemble les résultats et synthétise une sortie finale. Considérez l’orchestrator comme un chef de projet et les subagents comme les experts du domaine au sein de l’équipe.

Responsabilités de l’orchestrator

L’orchestrator assume trois responsabilités essentielles : la décomposition (diviser l’objectif en sous-tâches concrètes et réalisables), la délégation (attribuer chaque sous-tâche au spécialiste approprié) et la synthèse (combiner les sorties des subagents en un résultat cohérent). L’orchestrator effectue lui-même très peu de travail propre au domaine : sa valeur réside dans la coordination.

from openai import OpenAI

client = OpenAI()

def orchestrator(goal: str) -> dict:
    # Step 1: Decompose
    plan = client.chat.completions.create(
        model='gpt-4o',
        messages=[
            {'role': 'system', 'content': 'You are a task planner. Decompose the goal into subtasks. Return JSON with keys: researcher_task, writer_task, coder_task.'},
            {'role': 'user', 'content': goal}
        ],
        response_format={'type': 'json_object'}
    )
    return plan.choices[0].message.content

Concevoir des subagents spécialisés

Chaque subagent est optimisé pour une seule responsabilité. La spécialisation repose sur : un prompt système ciblé qui définit le rôle, un petit ensemble d’outils (3 à 5) pertinents uniquement pour ce rôle et une fenêtre de contexte qui ne contient que les informations nécessaires à cette sous-tâche. Les agents ciblés prennent de meilleures décisions et sont plus faciles à évaluer et à déboguer.

def create_researcher_agent():
    return {
        'model': 'gpt-4o',
        'system': '''You are a research specialist. Your only job is to find accurate,
            cited information. Return structured findings with sources.
            Do NOT write prose or code - only research findings.''',
        'tools': ['search_web', 'fetch_url', 'query_arxiv'],  # 3 tools only
        'max_iterations': 10
    }

def create_writer_agent():
    return {
        'model': 'gpt-4o',
        'system': '''You are a technical writer. Transform research findings into clear,
            engaging prose. You receive structured data and return polished text.''',
        'tools': ['format_markdown', 'check_readability'],  # 2 tools only
        'max_iterations': 5
    }

Le protocole de délégation

Pour que la délégation fonctionne, l'orchestrateur doit transmettre des paquets de tâches bien formés à chaque sous-agent. Un paquet de tâches comprend : l'objectif précis de ce sous-agent, le contexte pertinent dont il a besoin (et non l'historique complet de la conversation), le format de sortie attendu et les éventuelles contraintes. Les paquets de tâches mal formés sont la source la plus fréquente des échecs entre l'orchestrateur et les sous-agents.

from dataclasses import dataclass
from typing import Optional

@dataclass
class TaskPacket:
    task_id: str
    assignee: str          # which subagent receives this
    goal: str              # specific, actionable goal
    context: str           # only relevant background
    output_format: str     # JSON schema or description
    constraints: list[str] # e.g. ['max 500 words', 'cite sources']
    deadline_steps: int    # max iterations allowed

def delegate(packet: TaskPacket, subagent_fn) -> str:
    prompt = f'Goal: {packet.goal}\nContext: {packet.context}\nOutput format: {packet.output_format}\nConstraints: {packet.constraints}'
    return subagent_fn(prompt)

Collecte et synthèse des résultats

Une fois que les sous-agents ont terminé leur travail, l'orchestrateur doit synthétiser les résultats. Il ne s'agit pas d'une simple concaténation. L'orchestrateur doit résoudre les contradictions entre les sorties des sous-agents, combler les lacunes, conserver un ton ou un format cohérent et produire un résultat final cohérent dans son ensemble. C'est lors de cette étape de synthèse que les capacités de raisonnement de l'orchestrateur sont les plus sollicitées.

def synthesize_results(research: str, draft: str, code: str, goal: str) -> str:
    synthesis_prompt = f'''You are given outputs from three specialist agents.
    Your job is to synthesize them into one coherent final answer for this goal: {goal}

    RESEARCH FINDINGS:
    {research}

    WRITTEN DRAFT:
    {draft}

    CODE EXAMPLES:
    {code}

    Resolve any conflicts, fill gaps, and produce a unified final response.
    '''
    response = client.chat.completions.create(
        model='gpt-4o',
        messages=[{'role': 'user', 'content': synthesis_prompt}]
    )
    return response.choices[0].message.content

Délégation séquentielle ou parallèle

Les orchestrateurs peuvent déléguer des tâches séquentiellement (la sortie d'un sous-agent alimente le suivant) ou en parallèle (plusieurs sous-agents travaillent simultanément). La délégation séquentielle est plus simple et convient lorsque les étapes suivantes dépendent des résultats précédents. La délégation parallèle est plus rapide lorsque les sous-tâches sont indépendantes et peuvent s'exécuter simultanément, ce qui réduit souvent le temps d'exécution de 3 à 5 fois.

import asyncio

# Sequential: writer needs research first
async def sequential_pipeline(goal):
    research = await researcher_agent(goal)
    draft = await writer_agent(research)  # depends on research
    return draft

# Parallel: all three tasks are independent
async def parallel_pipeline(topics):
    tasks = [
        researcher_agent(topics[0]),
        researcher_agent(topics[1]),
        researcher_agent(topics[2])
    ]
    results = await asyncio.gather(*tasks)  # runs simultaneously
    return orchestrator_synthesize(results)

Gérer les échecs des sous-agents

Les sous-agents échouent parfois : ils peuvent renvoyer une sortie mal formée, dépasser leur limite d'itérations ou rencontrer une erreur. L'orchestrateur doit gérer ces échecs avec élégance. Parmi les stratégies courantes figurent les suivantes : réessayer avec un paquet de tâches clarifié, utiliser une solution de repli plus simple, ignorer la sous-tâche échouée en le signalant dans la sortie finale ou transmettre le problème à un humain pour révision.

def delegate_with_retry(packet: TaskPacket, subagent_fn, max_retries=2):
    for attempt in range(max_retries + 1):
        try:
            result = subagent_fn(packet)
            validate_output(result, packet.output_format)
            return result
        except ValidationError as e:
            if attempt < max_retries:
                # Clarify the task for retry
                packet.goal += f'\n\nPrevious attempt failed: {str(e)}. Please fix.'
                print(f'Retry {attempt + 1} for task {packet.task_id}')
            else:
                return {'error': str(e), 'task_id': packet.task_id, 'status': 'failed'}

Bien guider l'orchestrateur

Le prompt système de l'orchestrateur est essentiel à la qualité de l'ensemble de la chaîne de traitement. Il doit définir clairement : les sous-agents disponibles et la spécialité de chacun, la manière de formater les paquets de tâches, les situations dans lesquelles exécuter les sous-tâches en parallèle ou séquentiellement, la façon de gérer les résultats incomplets ou contradictoires et les critères d'une sortie finale réussie.

ORCHESTRATOR_SYSTEM_PROMPT = '''
You coordinate a team of specialist agents to complete complex tasks.

Available agents:
- researcher: Finds and cites factual information. Input: question string. Output: JSON with findings and sources.
- writer: Writes polished prose from structured data. Input: JSON findings. Output: markdown text.
- coder: Writes Python code. Input: natural language spec. Output: Python code string.

Workflow:
1. Analyze the goal and decide which agents are needed.
2. Identify dependencies: can any tasks run in parallel?
3. Delegate tasks with clear, specific goals.
4. Validate each result before proceeding.
5. Synthesize all results into a unified final answer.
'''

L'isolation du contexte est un atout

L'un des grands avantages du modèle orchestrateur-sous-agent est l'isolation du contexte. Chaque sous-agent ne voit que les informations pertinentes pour sa sous-tâche, et non l'historique complet du projet. Cela maintient une fenêtre de contexte réduite pour chaque sous-agent et évite l'épuisement du contexte qui affecte les agents uniques. L'orchestrateur conserve la vue globale, tandis que les sous-agents gardent des vues locales ciblées.

Traçage et observabilité

Les systèmes multi-agents sont plus difficiles à déboguer que les agents uniques, car des échecs peuvent se produire à chaque étape de délégation. Ajoutez toujours une journalisation structurée pour suivre : les tâches déléguées, le sous-agent auquel elles ont été confiées, leurs entrées et sorties, la durée de chacune et la nécessité éventuelle de nouvelles tentatives. Des outils comme LangSmith et Langfuse prennent en charge la visualisation des traces multi-agents.

import time

def logged_delegate(packet: TaskPacket, subagent_fn):
    start = time.time()
    print(f'[DELEGATE] task_id={packet.task_id} assignee={packet.assignee}')
    print(f'[INPUT] {packet.goal[:100]}...')
    
    result = subagent_fn(packet)
    elapsed = time.time() - start
    
    print(f'[RESULT] task_id={packet.task_id} elapsed={elapsed:.2f}s')
    print(f'[OUTPUT] {str(result)[:100]}...')
    return result

Exemple concret : générateur de rapports

Un exemple concret du modèle orchestrateur-sous-agent est un générateur de rapports d'analyse concurrentielle. L'orchestrateur reçoit la demande « Rédigez une analyse du concurrent de l'entreprise X ». Il délègue : la sous-tâche de recherche à un agent de recherche (qui trouve les tarifs, les fonctionnalités et les avis), la sous-tâche d'analyse à un agent analyste (qui identifie les forces et les faiblesses) et la sous-tâche de mise en forme à un agent rédacteur (qui produit le rapport final). Chaque spécialiste fait ce qu'il sait le mieux faire.

Vérification rapide

Testez votre compréhension du modèle orchestrateur-sous-agent présenté dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que le modèle orchestrateur-sous-agent utilise un agent coordinateur pour décomposer le travail et le déléguer à des spécialistes, que les paquets de tâches doivent définir clairement l'objectif, le contexte et le format de sortie attendu pour que la délégation fonctionne, et que l'isolation du contexte conserve une fenêtre réduite pour chaque sous-agent tandis que l'orchestrateur maintient la vue globale. Dans la prochaine leçon, nous construirons des chaînes de traitement multi-agents avec LangGraph.

Questions Fréquemment Posées

La leçon « Modèle orchestrateur-sous-agent » est-elle gratuite ?

Oui — le texte complet de « Modèle orchestrateur-sous-agent » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Modèle orchestrateur-sous-agent » ?

Implémentez le modèle orchestrateur-sous-agent : un agent planificateur décompose les tâches en sous-tâches, les délègue à des agents spécialisés, puis synthétise leurs résultats en une sortie finale. Tu pratiques AI Engineering Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Engineering Academy ?

Aucune expérience préalable n'est requise. AI Engineering Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Modèle orchestrateur-sous-agent » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Engineering Academy ?

Oui. Chaque leçon AI Engineering Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Pourquoi les agents uniques atteignent leurs limites
  2. Modèle orchestrateur-sous-agent
  3. Créer des pipelines multi-agents avec LangGraph
  4. Mémoire partagée et communication inter-agents
← Retour à AI Engineering Academy