Agents parallèles avec OpenProse : tutoriel complet

OpenProse permet d'exécuter plusieurs agents simultanément et de fusionner leurs sorties dans une session finale — sans écrire une ligne de Python. Ce tutoriel vous guide pas à pas dans la création de deux programmes .prose : un premier qui lance un chercheur et un rédacteur en parallèle avant de fusionner leurs résultats, un second qui itère en boucle conditionnelle jusqu'à validation. Consultez le guide complet OpenProse si vous découvrez l'outil pour la première fois.

Résumé rapide

1. Installer OpenProse et vérifier l'accès au modèle opus-1.5.
2. Déclarer vos agents avec leurs skills et prompts système.
3. Utiliser le bloc parallel: pour lancer des sessions simultanées.
4. Nommer chaque résultat (resultats, brouillon) pour les passer en contexte.
5. Ajouter une session de fusion qui reçoit toutes les sorties via context:.
6. Pour les boucles, ajouter un bloc loop until avec une condition en gras et un max: obligatoire.

Prérequis

Avant de commencer ce tutoriel, assurez-vous d'avoir :

• OpenProse installé dans votre environnement OpenClaw. Suivez le guide Installer OpenProse dans OpenClaw si ce n'est pas encore fait.
• Le modèle opus-1.5 disponible et configuré dans votre profil OpenProse (vérifiez avec /prose models).
• Une connaissance de base de la syntaxe .prose : agents, sessions et contrôle de flux. L'article Syntaxe .prose : agents, sessions et contrôle de flux couvre tous les blocs utilisés ici.
• Le CLI OpenProse installé globalement (npm install -g openprose ou équivalent).

Tutoriel

Programme 1 : parallel + fusion (chercheur + rédacteur → session finale)

Ce premier programme illustre le pattern le plus courant en multi-agents OpenProse : deux agents travaillent simultanément sur le même sujet, puis une troisième session fusionne leurs sorties en une réponse cohérente.

Étape 1 — Créer le fichier programme

Créez un fichier recherche-synthese.prose à la racine de votre projet.

Étape 2 — Déclarer l'input

# Recherche et synthèse en parallèle avec deux agents

input topic: "Changements climatiques"

La directive input définit une variable accessible partout dans le programme via {topic}. Vous pouvez la surcharger à l'exécution avec --input topic="Autre sujet".

Étape 3 — Déclarer les agents

agent chercheur:
  model: opus-1.5
  skills: ["web-search"]
  prompt: "Tu es un chercheur expert qui recherche des sources et cite tes références."

agent redacteur:
  model: opus-1.5
  prompt: "Tu es un rédacteur chargé de résumer clairement."

Chaque bloc agent définit :

• model : le modèle LLM utilisé pour toutes les sessions de cet agent.
• skills : liste optionnelle de capacités supplémentaires (web-search, code-exec, etc.).
• prompt : le prompt système qui définit la personnalité et le rôle de l'agent.

Ici, chercheur dispose du skill web-search pour interroger le web. redacteur n'a pas de skill spécifique — il travaille uniquement avec le langage.

Étape 4 — Écrire le bloc parallel

parallel:
  resultats = session: chercheur
    prompt: "Recherche des informations sur {topic}."
  brouillon = session: redacteur
    prompt: "Rédige un résumé sur {topic}."

Le bloc parallel: est la clé du tutoriel. Tout ce qu'il contient s'exécute simultanément :

• resultats = session: chercheur lance une session de l'agent chercheur et stocke sa sortie dans la variable resultats.
• brouillon = session: redacteur lance une session de l'agent redacteur et stocke sa sortie dans brouillon.

Les deux sessions tournent en parallèle : le temps d'exécution total est celui de la session la plus lente, pas la somme des deux.

Étape 5 — Ajouter la session de fusion

session "Fusionne les résultats en réponse finale."
  context: { resultats, brouillon }

Cette session anonyme (sans agent déclaré, donc avec le modèle par défaut) reçoit dans son contexte les deux variables produites par le bloc parallel. Le prompt inline ("Fusionne les résultats en réponse finale.") est sa consigne. L'IA dispose des deux textes et produit une synthèse consolidée.

Programme complet

# Recherche et synthèse en parallèle avec deux agents

input topic: "Changements climatiques"

agent chercheur:
  model: opus-1.5
  skills: ["web-search"]
  prompt: "Tu es un chercheur expert qui recherche des sources et cite tes références."

agent redacteur:
  model: opus-1.5
  prompt: "Tu es un rédacteur chargé de résumer clairement."

parallel:
  resultats = session: chercheur
    prompt: "Recherche des informations sur {topic}."
  brouillon = session: redacteur
    prompt: "Rédige un résumé sur {topic}."

session "Fusionne les résultats en réponse finale."
  context: { resultats, brouillon }

Diagramme du flux d'exécution

flowchart LR
  P[Programme .prose] --> C1[Session: Chercheur]
  P --> C2[Session: Rédacteur]
  C1 --> F[Résultats Recherche]
  C2 --> B[Brouillon Réponse]
  F & B --> M[Session Finale - Fusion]

---

Programme 2 : parallel + loop until conditionnel (analyste × 2 → écrivain en boucle)

Ce second programme introduit deux mécaniques supplémentaires : l'utilisation du même agent dans plusieurs sessions parallèles et la boucle conditionnelle loop until.

Étape 1 — Créer le fichier programme

Créez un fichier rapport-iteratif.prose.

Étape 2 — Déclarer les agents

# Itération pour améliorer la synthèse jusqu'à validation

agent analyste:
  model: opus-1.5
  skills: ["web-search"]
  prompt: "Tu es un expert qui recherche des données précises."

agent ecrivain:
  model: opus-1.5
  prompt: "Tu es un auteur qui rédige une synthèse formelle."

Notez que l'agent analyste sera utilisé deux fois dans le bloc parallel. OpenProse crée deux instances isolées du même agent pour les exécuter en parallèle — elles ne partagent pas de contexte entre elles.

Étape 3 — Lancer les deux sessions d'analyse en parallèle

parallel:
  donnees = session: analyste
    prompt: "Récupère des statistiques sur l'IA en 2026."
  references = session: analyste
    prompt: "Donne-moi des références de publications récentes sur ce sujet."

Les deux instances de analyste s'exécutent simultanément sur des tâches différentes. La première collecte des données chiffrées, la seconde des références bibliographiques. Chaque sortie est stockée dans une variable distincte.

Étape 4 — Ajouter la boucle conditionnelle

loop until **"synthèse acceptée"** (max: 3):
  session: ecrivain
    prompt: "Rédige un rapport sur {donnees} et {references}, puis améliore-le selon les consignes."

Le bloc loop until est le mécanisme d'itération d'OpenProse :

• until **"synthèse acceptée"** : la condition d'arrêt est une chaîne en gras dans la syntaxe .prose. Cette condition est évaluée par le LLM lui-même — pas par du code. Après chaque itération, OpenProse demande à l'IA si la condition est remplie ; si oui, la boucle s'arrête.
• (max: 3) : nombre maximum d'itérations autorisées. Ce paramètre est obligatoire. Sans lui, si la condition n'est jamais satisfaite, le programme tourne indéfiniment — voir la section Bonnes pratiques.

À chaque itération, ecrivain dispose des variables donnees et references dans son contexte (propagées automatiquement depuis le bloc précédent) et peut améliorer son rapport en tenant compte des consignes de la boucle.

Programme complet

# Itération pour améliorer la synthèse jusqu'à validation

agent analyste:
  model: opus-1.5
  skills: ["web-search"]
  prompt: "Tu es un expert qui recherche des données précises."

agent ecrivain:
  model: opus-1.5
  prompt: "Tu es un auteur qui rédige une synthèse formelle."

parallel:
  donnees = session: analyste
    prompt: "Récupère des statistiques sur l'IA en 2026."
  references = session: analyste
    prompt: "Donne-moi des références de publications récentes sur ce sujet."

loop until **"synthèse acceptée"** (max: 3):
  session: ecrivain
    prompt: "Rédige un rapport sur {donnees} et {references}, puis améliore-le selon les consignes."

Checklist de validation avant exécution

• Chaque agent a un model et un prompt définis.
• Les variables du bloc parallel ont des noms uniques (donnees, references).
• Le bloc loop until contient un max: non nul.
• La condition loop until est formulée en gras avec **...**.
• Les variables issues du parallel sont référencées avec {variable} dans le prompt de la boucle.
• Le fichier est sauvegardé avec l'extension .prose.

Exemple concret

Voici un programme combiné qui enchaîne les deux patterns : collecte parallèle puis boucle d'amélioration, avec lecture du state final.

# Pipeline complet : collecte parallèle + itération qualité

input sujet: "Impact de l'IA générative sur le marché du travail en 2026"

agent veilleur:
  model: opus-1.5
  skills: ["web-search"]
  prompt: "Tu es un analyste de veille technologique rigoureux."

agent redacteur:
  model: opus-1.5
  prompt: "Tu es un rédacteur spécialisé en rapports professionnels."

parallel:
  stats = session: veilleur
    prompt: "Trouve des statistiques récentes sur {sujet}."
  opinions = session: veilleur
    prompt: "Collecte des avis d'experts et des études de cas sur {sujet}."

loop until **"rapport complet et sourcé"** (max: 4):
  session: redacteur
    prompt: "Rédige un rapport de 500 mots sur {sujet} en intégrant {stats} et {opinions}. Améliore la version précédente si elle existe."

Exécuter le programme :

/prose run pipeline-complet.prose

Lire l'état enregistré :

OpenProse enregistre automatiquement l'état de chaque exécution dans .prose/runs/{timestamp}/state.md. Ce fichier contient :

• Les sorties de chaque session numérotées.
• La valeur des variables à chaque étape.
• L'historique des itérations de la boucle avec l'évaluation de la condition.

cat .prose/runs/2026-03-23T10-42-00/state.md

Le state.md est particulièrement utile pour déboguer une condition loop until qui ne se déclenche jamais : vous pouvez y lire exactement comment l'IA a évalué la condition à chaque tour.

Bonnes pratiques

Nommer explicitement vos sessions parallèles. Des noms descriptifs (stats, references, brouillon) rendent le programme lisible et évitent les confusions si vous ajoutez des variables plus tard. Évitez les noms génériques comme res1, res2.

Toujours définir max: dans un loop until. C'est la règle la plus importante : sans ce paramètre, si votre condition n'est jamais satisfaite par le LLM, le programme tourne indéfiniment et consomme des tokens sans limite. Commencez avec max: 3 en développement, ajustez en production.

Formuler des conditions claires et binaires. La condition **"synthèse acceptée"** est évaluée par l'IA — ce n'est pas du code. Préférez des formulations tranchées ("rapport complet et sourcé", "validation réussie") plutôt que des jugements nuancés ("suffisamment bien") qui peuvent produire des évaluations incohérentes d'une itération à l'autre.

Lire le state.md après chaque run en développement. Ce fichier révèle ce que les agents ont réellement produit à chaque étape. C'est votre principal outil de débogage pour comprendre pourquoi une boucle s'est arrêtée trop tôt ou a atteint max:.

Consulter les bonnes pratiques de structuration de pipelines dans l'article Pipeline de contenu multi-agents pour des patterns avancés de composition de blocs parallel et loop.

Questions fréquentes

Combien d'agents peut-on lancer en parallèle dans OpenProse ? Il n'y a pas de limite stricte définie dans la syntaxe — vous pouvez ajouter autant de lignes que nécessaire dans un bloc parallel:. En pratique, le nombre est limité par les quotas de l'API du modèle utilisé et par la latence réseau. Au-delà de 5 à 6 sessions simultanées, surveillez les erreurs de rate limiting dans votre terminal.

La condition loop until est-elle fiable pour une logique critique ? La condition est évaluée par le LLM, pas par du code déterministe. Elle convient bien pour des jugements éditoriaux ("rapport acceptable", "contenu complet"), mais pas pour des validations strictes (vérifier qu'un nombre dépasse un seuil, valider un format JSON). Pour ces cas, utilisez un skill de vérification externe dans la session de la boucle.

Que se passe-t-il si un agent échoue dans un bloc parallel ? Par défaut, OpenProse interrompt l'exécution et enregistre l'erreur dans le state.md. La session de fusion ou la boucle suivante ne s'exécute pas. Vous pouvez ajouter un attribut on_error: skip sur une session pour ignorer les échecs non bloquants et continuer avec les variables disponibles.

Puis-je utiliser des modèles différents dans un même bloc parallel ? Oui. Chaque agent déclare son propre model. Vous pouvez donc avoir un agent opus-1.5 pour une tâche complexe et un agent avec un modèle plus léger pour une tâche simple, le tout dans le même parallel:. C'est un levier d'optimisation des coûts.

Comment passer une variable d'un parallel directement dans un autre parallel ? Les blocs parallel s'exécutent séquentiellement entre eux (les sessions à l'intérieur d'un même bloc sont parallèles). Vous pouvez donc déclarer un second parallel: après le premier et utiliser les variables du premier comme {variable} dans les prompts du second.

Articles liés

OpenProse offre de nombreux autres patterns d'orchestration au-delà des agents parallèles. L'article Syntaxe .prose : agents, sessions et contrôle de flux détaille l'ensemble des blocs disponibles — sequence, parallel, loop until, branch — avec leurs paramètres complets. Pour aller plus loin dans la construction de pipelines de production, Pipeline de contenu multi-agents montre comment combiner ces blocs pour automatiser la création d'articles à l'échelle.

---

Envie d'un cas concret en production ? Découvrez comment construire un pipeline de contenu multi-agents avec OpenProse.