design pattern agentique Parallelization Parallelisation

💡 Prompt Prêt à l’Emploi : Orchestrateur de Parallélisation

Contexte :

Ce prompt configure un orchestrateur qui décompose une tâche en sous-tâches parallèles, les lance simultanément, puis agrège les résultats. Idéal pour n8n, LangChain, ou tout framework supportant les appels asynchrones.

Étape 1 – Prompt de Décomposition (exécuté une fois au début) :

Tu es un orchestrateur de tâches parallèles.

**Tâche principale :**
[TACHE_PRINCIPALE]

**Instructions :**
1. Décompose cette tâche en sous-tâches INDÉPENDANTES (qui peuvent s'exécuter en parallèle sans dépendre les unes des autres)
2. Pour chaque sous-tâche, définis : un ID unique, un prompt spécifique, le timeout recommandé
3. Vérifie qu'aucune sous-tâche n'a besoin du résultat d'une autre

**Format de sortie (JSON) :**
{
  "tache_principale": "description courte",
  "sous_taches": [
    {
      "id": "analyse_securite",
      "prompt": "Analyse le code suivant pour détecter les failles de sécurité : [CONTENU]",
      "timeout_ms": 3000,
      "poids_agregation": 0.4
    },
    {
      "id": "analyse_performance", 
      "prompt": "Analyse le code suivant pour identifier les problèmes de performance : [CONTENU]",
      "timeout_ms": 2000,
      "poids_agregation": 0.3
    },
    {
      "id": "analyse_lisibilite",
      "prompt": "Analyse le code suivant pour évaluer sa lisibilité et maintenabilité : [CONTENU]",
      "timeout_ms": 2000,
      "poids_agregation": 0.3
    }
  ],
  "strategie_agregation": "moyenne_ponderee"
}

Étape 2 – Exécution Parallèle (pseudo-code) :

// Lancer toutes les sous-tâches EN MÊME TEMPS
const resultats = await Promise.all(
  sousTaches.map(tache => 
    appelLLM({
      prompt: tache.prompt.replace('[CONTENU]', contenuAnalyser),
      timeout: tache.timeout_ms
    })
  )
);

// Chaque résultat contient : {id, score, analyse, recommandations}

Étape 3 – Prompt d’Agrégation (exécuté une fois à la fin) :

Tu es un agrégateur de résultats d'analyses parallèles.

**Résultats reçus des agents :**
[RESULTATS_AGENTS]

**Pondérations :**
[PONDERATIONS]

**Instructions :**
1. Calcule le score global pondéré
2. Identifie les CONTRADICTIONS entre agents (ex: un dit "sécurisé", l'autre "vulnérable")
3. Si contradiction : signale-la et privilégie l'agent avec le poids le plus fort
4. Fusionne les recommandations par priorité (sécurité > performance > style)

**Format de sortie (JSON) :**
{
  "score_global": 0.72,
  "verdict": "APPROUVE | ATTENTION | BLOQUE",
  "scores_par_dimension": {
    "securite": 0.85,
    "performance": 0.60,
    "lisibilite": 0.70
  },
  "contradictions": [],
  "recommandations": [
    {"priorite": 1, "dimension": "performance", "action": "..."},
    {"priorite": 2, "dimension": "lisibilite", "action": "..."}
  ],
  "temps_execution_ms": 850
}

Variables à personnaliser :

• [TACHE_PRINCIPALE] : La tâche globale à paralléliser (ex: « Analyser cette pull request de 200 lignes Python »)
• [CONTENU] : Le contenu à analyser (code, texte, données)
• [RESULTATS_AGENTS] : Les réponses JSON collectées de chaque agent parallèle
• [PONDERATIONS] : Les poids définis à l’étape 1 (ex: sécurité: 0.4, performance: 0.3)

Flux complet :

Résultat attendu :

Un rapport unifié avec score global, analyse par dimension, et recommandations priorisées. Temps d’exécution ≈ temps de l’agent le plus lent + 200ms d’overhead.