Guide complet OpenProse 2026

OpenProse change la façon dont on orchestre des agents IA : plutôt que d'écrire du code Python ou JavaScript pour coordonner des LLM, on décrit le workflow en Markdown dans un fichier texte. Si vous utilisez déjà OpenClaw, OpenProse s'y intègre nativement via un plugin /prose. Ce guide couvre tout ce qu'il faut savoir pour écrire votre premier programme .prose et orchestrer des agents en parallèle, en boucle ou sous conditions.

Résumé rapide

• OpenProse est un langage de workflow Markdown pour l'orchestration de sessions IA multi-agents, sans code externe
• Les workflows sont déclarés dans des fichiers .prose lisibles par tout humain et tout environnement "Prose Complete"
• Le contrôle de flux inclut parallel:, loop until, if **condition**: et try/catch — les conditions en gras sont évaluées par l'IA
• L'inversion de contrôle place l'IA au centre : on décrit le quoi, l'IA coordonne le comment
• OpenProse est encore en version bêta : la syntaxe peut évoluer

Qu'est-ce qu'OpenProse ?

OpenProse est un langage de workflow spécialisé dans l'orchestration de sessions IA multi-agents. Son principe fondateur est simple : décrire, dans un fichier texte structuré (.prose), les agents, leurs invites et le contrôle de flux — sans jamais écrire de code dans un langage de programmation classique.

Le fichier .prose comme unité de base

Un fichier .prose est un document Markdown enrichi. Il contient des directives structurées qui définissent des agents (quel modèle, quel prompt, quels outils), des sessions (l'invocation d'un agent) et des blocs de contrôle de flux. Tout le workflow tient dans ce fichier texte versionnable, lisible et partageable.

Inversion de contrôle : l'IA pilote

La différence conceptuelle clé avec les orchestrateurs classiques (LangGraph, LangChain, CrewAI) est l'inversion de contrôle. Dans un orchestrateur Python traditionnel, c'est votre code qui pilote l'exécution pas à pas. Dans OpenProse, vous déclarez le workflow et c'est l'environnement "Prose Complete" qui prend en charge l'exécution, la coordination des sous-agents et la gestion des erreurs. On décrit le quoi, l'IA coordonne le comment.

Cette approche rapproche OpenProse du paradigme de la programmation déclarative : on spécifie le résultat souhaité, pas les étapes d'implémentation.

Portabilité et environnements "Prose Complete"

Un programme .prose s'exécute dans tout environnement déclaré "Prose Complete" — actuellement Claude (Anthropic), OpenAI et les implémentations compatibles Opus. Il n'existe pas de dépendance externe à installer : le moteur d'exécution est le LLM lui-même. Cette portabilité est l'un des atouts majeurs du format.

Pour comparer OpenProse avec d'autres approches d'orchestration, voir OpenProse vs LangChain vs prompts bruts.

Les composants fondamentaux

OpenProse repose sur quatre briques conceptuelles : les programmes, les agents, les sessions et les structures de contrôle de flux. Leur compréhension est indispensable pour écrire des workflows efficaces.

Programme

Le programme est l'unité principale d'OpenProse : c'est le fichier .prose lui-même. Il commence généralement par un titre Markdown (ligne #) qui décrit l'objectif global, et peut accepter des entrées via la directive input.

# Mon premier workflow OpenProse

input topic: "Intelligence artificielle"

La directive input déclare une variable d'entrée accessible dans tout le programme via la notation {topic}.

Agent

Un agent est une entité IA déclarée avec la directive agent nom:. Il possède trois attributs principaux :

• model: — le modèle LLM à utiliser (ex. opus-1.5, gpt-4o)
• prompt: — la persona ou instruction système de l'agent
• skills: — les outils disponibles (ex. ["web-search", "code-interpreter"])

agent analyste:
  model: opus-1.5
  skills: ["web-search"]
  prompt: "Tu es un analyste expert. Tu cites toujours tes sources."

Un agent ne s'exécute pas seul : il est invoqué via une session.

Session

Une session est l'invocation d'un agent pour une tâche précise. Elle peut être nommée (pour stocker le résultat dans une variable) ou anonyme.

Session nommée (résultat stocké) :

rapport = session: analyste
  prompt: "Analyse les tendances IA de 2026."

Session anonyme (résultat terminal) :

session "Synthétise le rapport précédent en 3 points clés."
  context: { rapport }

Le paramètre context: permet de passer des variables d'une session à l'autre, créant ainsi une chaîne de traitement entre agents.

Contrôle de flux

C'est là que OpenProse révèle toute sa puissance. Quatre structures permettent d'orchestrer des workflows complexes.

parallel: — exécution simultanée

Le bloc parallel: lance plusieurs sessions en même temps. Les résultats sont disponibles une fois toutes les sessions terminées.

parallel:
  resultat_a = session: agent_a
    prompt: "Tâche A."
  resultat_b = session: agent_b
    prompt: "Tâche B."

C'est l'équivalent d'un Promise.all() en JavaScript ou d'un asyncio.gather() en Python, mais exprimé en Markdown.

loop until **condition** — boucle conditionnelle

La boucle s'exécute jusqu'à ce qu'une condition (évaluée par l'IA) soit vérifiée. L'attribut max: définit un nombre maximum d'itérations pour éviter les boucles infinies.

loop until **la qualité du texte est suffisante** (max: 5):
  brouillon = session: redacteur
    prompt: "Améliore ce brouillon : {brouillon}"

La condition en gras est une instruction en langage naturel interprétée par l'IA — c'est l'inversion de contrôle en action.

if **condition**: — branchement conditionnel

Les conditions en gras permettent des branchements basés sur l'évaluation sémantique du contenu, pas sur des comparaisons de valeurs booléennes classiques.

if **le rapport contient des données contradictoires**:
  verification = session: verificateur
    prompt: "Vérifie et réconcilie les données de {rapport}."

try/catch — gestion d'erreurs

Le bloc try/catch permet de gérer les échecs d'une session et de définir un comportement de repli.

try:
  donnees = session: scraper
    prompt: "Extrais les données de ce site web."
catch:
  donnees = session: analyste
    prompt: "Les données web sont indisponibles. Utilise tes connaissances internes."

Pour aller plus loin sur la syntaxe complète, consultez Syntaxe .prose : agents, sessions et contrôle de flux. Pour l'intégration dans OpenClaw, voir Installer OpenProse dans OpenClaw.

Diagramme du flux d'exécution

flowchart TD
    A[Fichier .prose] --> B[Déclaration des agents]
    B --> C{Contrôle de flux}
    C -->|parallel| D[Sessions simultanées]
    C -->|loop until| E[Boucle conditionnelle]
    C -->|if condition| F[Branchement sémantique]
    C -->|try/catch| G[Gestion d'erreurs]
    D --> H[Fusion via context]
    E --> H
    F --> H
    G --> H
    H --> I[Session finale / Sortie]

Exemple concret

Voici un programme .prose complet qui orchestre deux agents en parallèle — un chercheur et un rédacteur — puis fusionne leurs productions dans une session finale.

# 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 }

Ce qui se passe à l'exécution :

1. L'environnement Prose Complete instancie les deux agents avec leurs configurations respectives
2. Le bloc parallel: lance simultanément les deux sessions — le chercheur effectue des recherches web pendant que le rédacteur produit un premier brouillon
3. Une fois les deux sessions terminées, leurs sorties (resultats et brouillon) sont passées via context: à la session finale
4. La session finale fusionne les deux productions en une réponse cohérente

Ce pattern — agents spécialisés en parallèle, fusion finale — est l'un des plus utilisés dans les workflows de production de contenu et de recherche augmentée.

Bonnes pratiques

Portabilité et versioning

Traitez vos fichiers .prose comme du code source : versionnez-les dans Git, utilisez des noms de fichiers descriptifs et organisez-les en répertoires par domaine fonctionnel. Leur format texte les rend parfaitement adaptés aux diff et aux revues de code.

Toujours définir un max: sur les boucles

Une boucle sans limite maximale peut consommer des tokens indéfiniment si la condition IA n'est jamais satisfaite. Définissez systématiquement (max: N) avec une valeur raisonnable selon le contexte (3 à 10 selon la complexité de la tâche).

Gestion bêta : éviter les dépendances critiques

OpenProse est en version bêta. La syntaxe peut évoluer entre versions. Évitez de l'utiliser en production pour des systèmes critiques sans maintenir une couche d'abstraction ou un plan de migration. Documentez la version Prose Complete utilisée dans chaque projet.

Sécurité et contenu des prompts

Les variables d'entrée (input) peuvent contenir du contenu utilisateur. Appliquez le principe de moindre privilège : un agent ne devrait avoir accès qu'aux skills dont il a réellement besoin. Évitez de passer des données sensibles (clés API, données personnelles) dans les context: sans chiffrement préalable.

Structurer les workflows complexes

Pour les pipelines multi-étapes, décomposez le workflow en plusieurs fichiers .prose modulaires plutôt qu'un seul fichier monolithique. Voir Pipeline de contenu multi-agents pour un exemple de découpage par responsabilité.

---

Prêt à écrire votre premier programme .prose ? Suivez le guide d'installation OpenProse pour démarrer en 10 minutes.

Questions fréquentes

OpenProse est-il un langage de programmation ? Non au sens classique : OpenProse ne compile pas vers du bytecode et ne s'exécute pas sur une machine virtuelle. C'est un langage de workflow déclaratif interprété par un LLM dans un environnement "Prose Complete". La distinction est importante : il n'y a pas de typage, pas de gestion mémoire manuelle, pas de débogueur au sens traditionnel.

Quelle est la différence entre un agent et une session dans OpenProse ? Un agent est une définition : il spécifie un modèle, un prompt système et des outils. Une session est une invocation de cet agent pour une tâche précise. On peut invoquer le même agent dans plusieurs sessions distinctes avec des prompts différents — comme instancier plusieurs fois une même classe dans un langage orienté objet.

OpenProse peut-il s'exécuter sans OpenClaw ? Oui. OpenProse tourne dans tout environnement "Prose Complete" — Claude.ai, interfaces OpenAI compatibles, ou toute implémentation déclarant la conformité Prose Complete. OpenClaw offre une intégration native via le plugin /prose, mais n'est pas obligatoire.

Les conditions en gras sont-elles fiables ? Les conditions évaluées par l'IA (ex. **la qualité est suffisante**) sont sémantiques, pas déterministes. Elles peuvent varier selon le modèle et le contexte. Pour des conditions critiques qui nécessitent une fiabilité absolue, préférez des sessions dédiées à la vérification avec des critères explicites dans le prompt, plutôt que de compter uniquement sur l'évaluation implicite.

OpenProse gère-t-il l'état entre plusieurs exécutions ? Non nativement. Chaque exécution d'un fichier .prose est sans état par défaut. Pour persister des données entre exécutions, il faut utiliser un skill de stockage externe (base de données, fichier) via les skills: d'un agent.

Articles liés

Pour approfondir l'écosystème OpenProse, deux ressources complémentaires sont indispensables. La page Syntaxe .prose : agents, sessions et contrôle de flux documente exhaustivement chaque directive avec des exemples pour chaque cas limite. Si vous souhaitez situer OpenProse dans le paysage des orchestrateurs IA, OpenProse vs LangChain vs prompts bruts met en regard les compromis de chaque approche selon la complexité du workflow et le profil de l'équipe.