AI Prompt Engineering · Leçon

Orchestrateur et travailleurs

Coordination hiérarchique.

Leçon 2 sur 413 étapes

Orchestrateur et travailleurs est une leçon AI Prompt Engineering 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 Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.

Le modèle du coordinateur

Dans le modèle coordinateur-exécutants, un seul agent coordinateur est responsable du plan et de l’objectif ; les agents exécutants réalisent des sous-tâches délimitées et rendent compte de leur travail. Le coordinateur décompose, répartit, intègre et décide quand la tâche est terminée.

  • Coordinateur : planification, routage, synthèse, flux de contrôle.
  • Exécutants : exécution ciblée dans le cadre d’un contrat strict.

Cette hiérarchie concentre le jugement en un point et le travail parallélisable en plusieurs.

Séparation de la planification et de l’exécution

La discipline essentielle consiste à séparer la planification de l’exécution. Le coordinateur réfléchit à la stratégie avec un contexte restreint et de haut niveau ; les exécutants travaillent avec un contexte détaillé mais étroit. Les mélanger recrée le généraliste surchargé.

Le coordinateur devrait rarement manipuler directement les sorties brutes des outils : il raisonne à partir des résumés produits par les exécutants.

plan = orchestrator.decompose(goal)        # high-level
results = [worker.run(sub) for sub in plan] # detailed, scoped
final = orchestrator.integrate(results)     # over summaries

La qualité de la décomposition détermine tout

La qualité du système dépend entièrement de la décomposition réalisée par le coordinateur. Les sous-tâches doivent être suffisamment indépendantes pour être exécutées en parallèle, suffisamment délimitées pour être transmises proprement et complètes dans leur ensemble. Demandez au coordinateur de produire un plan explicite que vous pourrez examiner avant l’exécution de tout agent.

  • Sous-tâches indépendantes -> exécution en parallèle.
  • Couverture complète -> aucune lacune dans la réponse finale.
plan = {
  'subtasks': [
    {'id': 1, 'goal': '...', 'inputs': [...], 'depends_on': []},
    {'id': 2, 'goal': '...', 'inputs': [...], 'depends_on': [1]}
  ]
}

Distribuer avec des contrats stricts

Chaque distribution fournit à un exécutant exactement son objectif, ses entrées et le schéma de sortie attendu — rien de plus. Un exécutant qui ne connaît que sa partie ne peut pas être distrait par l’objectif global et renvoie une structure prévisible que le coordinateur peut faire passer à integrate.

Le message de distribution est un contrat : livrable clair, format clair, critères d’achèvement clairs.

dispatch = {
  'goal': 'Summarize doc 7 risks',
  'context': doc7,
  'output_schema': {'risks': [{'text': str, 'severity': str}]},
  'done_when': 'all risk clauses covered'
}

Isolation du contexte entre les exécutants

Par défaut, les exécutants ne devraient pas voir l’intégralité du contexte des autres. L’isolation empêche les erreurs ou les hallucinations d’un exécutant de contaminer un autre et conserve à chaque invite d’exécutant une taille réduite, ce qui facilite sa mise en cache. Le coordinateur est le seul composant à disposer d’une vue globale.

Ne partagez des informations entre exécutants que par l’intermédiaire des résumés vérifiés du coordinateur, jamais par des échanges directs et bruts.

Sous-tâches en parallèle ou séquentielles

Les sous-tâches indépendantes effectuent un run en parallèle pour réduire la latence ; les sous-tâches dépendantes doivent respecter l’ordre. Le plan du coordinateur encode un graphe de dépendances et le moteur d’exécution planifie en conséquence : diffusez les feuilles indépendantes, puis regroupez-les.

  • Diffusion : distribuez simultanément toutes les sous-tâches prêtes.
  • Regroupement : attendez les dépendances avant de distribuer une sous-tâche dépendante.
def schedule(plan):
    ready = [t for t in plan if not t['depends_on']]
    run_parallel(ready)
    # then unlock tasks whose deps are now done

Intégration et résolution des conflits

L’intégration ne consiste pas en une concaténation. Le coordinateur doit appliquer l’opération reconcile aux sorties qui se chevauchent, se contredisent ou présentent un faible niveau de confiance afin de produire un résultat cohérent, en déterminant lesquelles méritent sa confiance et en signalant les conflits non résolus.

Donnez au coordinateur une étape explicite de réconciliation avec des règles : privilégier les éléments présentant une confiance supérieure, signaler les contradictions et demander un nouveau run lorsque la couverture est incomplète.

merged = orchestrator.reconcile(
  results,
  rules='prefer higher confidence; flag contradictions; re-dispatch on gaps'
)

Le coordinateur comme contrôleur

Le coordinateur est également responsable du flux de contrôle : il décide quand s’arrêter, quand réessayer avec un exécutant défaillant, quand replanifier et quand faire remonter le problème. C’est donc à cet endroit qu’il faut imposer les budgets — nombre maximal d’itérations, dépense maximale, profondeur maximale — afin d’empêcher les boucles incontrôlées.

Sans coordinateur contrôleur, les systèmes multi-agents s’emballent.

if iterations > MAX_ITERS or spend > BUDGET:
    return orchestrator.best_effort_answer()

Décomposition récursive

Un exécutant peut lui-même jouer le rôle de coordinateur pour un sous-problème, formant ainsi une hiérarchie. Cette approche permet de traiter des tâches profondes, mais ajoute de la latence et de la profondeur à la propagation des erreurs. Limitez la profondeur de récursion et exigez que chaque niveau renvoie un résumé clair, afin que les niveaux supérieurs ne soient jamais noyés dans les détails des niveaux inférieurs.

Confinement des défaillances

Concevez le système de manière à ce qu’une seule défaillance d’un exécutant dégrade le résultat avec élégance. Le coordinateur doit détecter une sortie mal formée ou vide, réessayer avec un contrat clarifié et utiliser fallback plutôt que de planter. Les exécutants échouent de manière isolée ; le coordinateur absorbe la défaillance et l’évite.

  • Validez chaque résultat d’exécutant par rapport à son schéma.
  • Réessayez puis utilisez fallback ; ne transmettez jamais une défaillance brute vers le niveau supérieur.
def collect(worker, dispatch):
    out = worker.run(dispatch)
    if not valid(out, dispatch['output_schema']):
        out = worker.run(clarify(dispatch))
    return out or fallback(dispatch)

Plan directeur de l’orchestration

Le plan directeur est le suivant : le coordinateur décompose la tâche en un plan inspectable sous forme de graphe de dépendances, distribue des contrats stricts à des exécutants isolés, exécute les sous-tâches indépendantes en parallèle, valide et réconcilie les résultats selon des règles explicites de résolution des conflits, impose des budgets et des conditions d’arrêt, puis contient les défaillances des exécutants grâce à un réessai suivi d’un fallback. Le jugement reste central ; le travail reste distribué.

Vérification rapide

Vous concevez un système orchestrateur-agents d’exécution pour une tâche de recherche comportant plusieurs sous-thèmes indépendants.

Récapitulatif : orchestrateur et agents d’exécution

Concentrez la planification, le routage, l’intégration et le contrôle dans un orchestrateur unique ; confiez l’exécution ciblée à des agents d’exécution isolés, régis par des contrats stricts. Décomposez la tâche en graphe de dépendances inspectable, exécutez en parallèle les sous-tâches indépendantes, rapprochez les résultats au moyen de règles explicites de résolution des conflits, imposez des budgets et des conditions d’arrêt, et contenez les défaillances des agents d’exécution grâce à une validation, un réessai et un repli. L’orchestrateur raisonne à partir de résumés, jamais à partir d’échanges bruts entre agents, ce qui maintient une hiérarchie cohérente et contrôlable.

Gratuit pour commencer

Apprends AI Prompt Engineering avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
53
Leçons
199

Questions Fréquemment Posées

La leçon « Orchestrateur et travailleurs » est-elle gratuite ?

Oui — le texte complet de « Orchestrateur et travailleurs » 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 Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Orchestrateur et travailleurs » ?

Coordination hiérarchique. Tu pratiques AI Prompt Engineering 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 Prompt Engineering ?

Aucune expérience préalable n'est requise. AI Prompt Engineering 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 « Orchestrateur et travailleurs » ?

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 Prompt Engineering ?

Oui. Chaque leçon AI Prompt Engineering 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. Rôles et spécialisation
  2. Orchestrateur et travailleurs
  3. Communication entre agents
  4. Agents débatteurs et votants
← Retour à AI Prompt Engineering