Syntaxe .prose : agents, sessions et contrôle de flux

Un fichier .prose ressemble à un document structuré, mais c'est un programme à part entière. OpenProse a fait le pari d'une syntaxe lisible par des non-développeurs tout en restant suffisamment expressive pour orchestrer des pipelines multi-agents complexes. Ce guide de référence couvre chaque bloc syntaxique — de la déclaration d'agent à la gestion d'erreurs — avec des exemples de code pour chaque cas. Pour démarrer depuis zéro, consultez d'abord le guide complet OpenProse.

Résumé rapide

Bloc syntaxique	Rôle	Exemple minimal
input	Déclare une variable d'entrée	input url: "https://example.com"
agent	Définit un agent réutilisable	agent scout: model: opus-1.5
session	Exécute un agent sur une tâche	session: scout / prompt: "..."
parallel	Lance plusieurs sessions en même temps	parallel: / var1 = session: agent1 / var2 = session: agent2
loop until	Répète jusqu'à condition IA satisfaite	loop until **"contenu validé"** (max: 3):
if	Branchement conditionnel IA	if **"résultat suffisant"**:
try/catch	Gestion des erreurs d'exécution	try: ... catch: session: fallback
context	Partage de variables entre sessions	context: { donnees, references }

Qu'est-ce que la syntaxe .prose ?

OpenProse est un langage de programmation markdown-first conçu spécifiquement pour l'orchestration d'agents IA. Contrairement aux frameworks Python comme LangGraph ou CrewAI, OpenProse ne s'écrit pas dans un langage de programmation généraliste : la logique du programme réside dans un fichier texte avec l'extension .prose.

La philosophie centrale est que l'intelligence doit être dans le programme, pas dans le code qui l'exécute. Les conditions ne sont pas des expressions booléennes classiques (x > 5), mais des descriptions en langage naturel évaluées par le modèle LLM lui-même (**"résultat de qualité suffisante"**). Cela permet d'exprimer des critères flous que seule une IA peut interpréter.

Structure YAML hiérarchique : un fichier .prose utilise l'indentation pour exprimer la hiérarchie. Les blocs de premier niveau (agents, inputs) constituent le contexte global du programme. Les blocs de second niveau (sessions, parallel, loop) forment le flux d'exécution. Cette organisation est similaire à YAML mais avec une grammaire propre à OpenProse.

# Commentaire — ligne ignorée à l'exécution

input sujet: "agents IA"

agent chercheur:
  model: opus-1.5
  skills: ["web-search"]
  prompt: "Tu es un chercheur spécialisé en IA."

session: chercheur
  prompt: "Résume les avancées récentes sur {sujet}."

Markdown-first signifie que les prompts sont des textes en Markdown — les agents interprètent le formatage (titres, listes, gras) comme des instructions de structure. Les sorties produites par les agents respectent également le Markdown, ce qui facilite l'enchaînement entre agents.

La distinction fondamentale à retenir avant d'entrer dans le détail des blocs : un agent est une déclaration (configuration statique réutilisable), une session est une exécution (appel concret à un agent pour une tâche précise). Un agent peut être invoqué dans plusieurs sessions différentes au sein du même programme.

Les blocs syntaxiques en détail

Programme — le fichier .prose comme unité d'exécution

Un fichier .prose correspond à un programme complet. Il n'y a pas de fonction main ni de point d'entrée explicite : l'exécution suit les blocs de haut en bas, sauf quand le contrôle de flux (parallel, loop, if) en décide autrement.

# Mon premier programme OpenProse

input question: "Qu'est-ce que l'IA générative ?"

agent repondeur:
  model: opus-1.5
  prompt: "Tu réponds de façon concise et précise."

session: repondeur
  prompt: "Réponds à cette question : {question}"

Le runtime OpenProse charge le fichier, instancie les agents déclarés, résout les variables d'input, puis exécute le flux de sessions dans l'ordre.

Input — variables d'entrée du programme

Le bloc input déclare les paramètres que le programme reçoit au lancement. Chaque variable déclarée devient accessible dans toutes les sessions via la notation {nom_variable}.

input sujet: "machine learning"
input langue: "français"
input longueur: "500 mots"

Les inputs peuvent être surchargés au moment de l'appel, ce qui rend un fichier .prose paramétrable et réutilisable pour différents contextes sans modifier le programme lui-même.

Agent — déclaration d'un agent réutilisable

Un bloc agent configure un agent nommé. Il ne fait rien à lui seul — il définit comment l'agent se comportera quand une session l'invoquera.

agent analyste:
  model: opus-1.5
  skills: ["web-search", "calculator"]
  prompt: "Tu es un analyste de données qui cite toujours ses sources."

Les champs disponibles :

• model : identifiant du modèle LLM à utiliser (opus-1.5, sonnet-3.7, etc.)
• skills : liste des outils auxquels l'agent a accès (web-search, code-interpreter, etc.)
• prompt : instruction système permanente qui définit le rôle et le comportement de l'agent

Un agent peut être déclaré une fois et invoqué dans plusieurs sessions. La déclaration est statique ; le contexte d'exécution (prompt de tâche, variables) est fourni par chaque session.

Session — exécution d'une tâche par un agent

La session est le bloc d'action central d'OpenProse. Elle invoque un agent déclaré et lui soumet une tâche précise.

session: analyste
  prompt: "Analyse les tendances du marché IA en Europe en 2026."
  context: { sujet, langue }

Pour capturer le résultat dans une variable :

rapport = session: analyste
  prompt: "Produis un rapport sur {sujet}."
  context: { sujet }

La variable rapport contiendra la sortie textuelle de l'agent et pourra être référencée dans les sessions suivantes via {rapport} ou passée explicitement via context.

Le champ context est important : il détermine quelles variables du programme global l'agent peut "voir" pendant cette session. Sans context, l'agent n'a accès qu'aux variables transmises directement dans le prompt.

Parallel — sessions simultanées

Le bloc parallel lance plusieurs sessions en parallèle et attend que toutes soient terminées avant de poursuivre l'exécution. C'est le mécanisme clé pour accélérer les pipelines où plusieurs tâches sont indépendantes.

parallel:
  donnees_marche = session: analyste
    prompt: "Collecte les chiffres du marché IA mondial en 2026."
  donnees_europe = session: analyste
    prompt: "Collecte les chiffres spécifiques au marché européen."
  tendances = session: veilleur
    prompt: "Identifie les 5 principales tendances IA de ce trimestre."

Pour aller plus loin sur ce sujet, consultez notre guide sur les agents parallèles avec OpenProse.

Chaque branche du parallel peut utiliser un agent différent et capturer son résultat dans une variable distincte. Les variables (donnees_marche, donnees_europe, tendances) sont disponibles après la fermeture du bloc parallel.

Point d'attention : les sessions dans un parallel ne peuvent pas partager de variables entre elles — elles s'exécutent de façon strictement indépendante. Le partage de résultats se fait uniquement après la fin du bloc.

Loop until — répétition jusqu'à satisfaction d'une condition IA

Le bloc loop until répète un ensemble de sessions jusqu'à ce qu'une condition exprimée en langage naturel soit satisfaite. La condition **en gras** est évaluée par le modèle LLM — ce n'est pas un test booléen classique.

loop until **"le rapport contient au moins 5 sources vérifiées"** (max: 4):
  sources = session: chercheur
    prompt: "Trouve des sources supplémentaires sur {sujet}."
  rapport = session: redacteur
    prompt: "Améliore {rapport} en intégrant {sources}."
    context: { rapport, sources }

Le paramètre max: est obligatoire — il définit le nombre maximal d'itérations pour éviter les boucles infinies. Si la condition n'est pas atteinte après max itérations, le programme continue avec l'état courant des variables.

La notation **condition** (double astérisques) signale au runtime qu'il s'agit d'une condition IA à évaluer sémantiquement, non d'une expression à calculer. Cela autorise des critères comme **"ton suffisamment formel"**, **"toutes les questions soulevées ont une réponse"** ou **"le résumé ne dépasse pas 200 mots"**.

If — branchement conditionnel

Le bloc if exécute une section du programme seulement si la condition IA est vraie. Comme pour loop until, la condition est évaluée par le modèle.

if **"le sujet est technique et nécessite des explications détaillées"**:
  session: pedagogue
    prompt: "Ajoute une section d'explications vulgarisées à {rapport}."
    context: { rapport, sujet }

Il est possible d'enchaîner avec un bloc else pour le cas contraire :

if **"les données collectées sont suffisantes pour conclure"**:
  conclusion = session: redacteur
    prompt: "Rédige la conclusion de {rapport}."
else:
  session: chercheur
    prompt: "Collecte des données complémentaires sur {sujet}."

Try/catch — gestion des erreurs

Le bloc try/catch isole une section susceptible d'échouer et définit un comportement de repli en cas d'erreur.

try:
  donnees = session: analyste
    prompt: "Récupère les données temps réel via l'API externe."
    context: { url }
catch:
  donnees = session: analyste-fallback
    prompt: "Les données temps réel sont indisponibles. Utilise les données du {donnees_cache}."
    context: { donnees_cache }

Les erreurs capturées incluent les timeouts d'API, les erreurs de skills, et les échecs explicites signalés par un agent. Le bloc catch reçoit le contexte complet du programme au moment de l'erreur.

Context et variables — partage de données entre agents

Les variables dans OpenProse sont créées par assignation lors d'une session (variable = session: agent) ou déclarées via input. Le champ context d'une session détermine quelles variables sont visibles par l'agent pendant son exécution.

input domaine: "cybersécurité"

rapport_initial = session: redacteur
  prompt: "Rédige une introduction sur {domaine}."
  context: { domaine }

rapport_enrichi = session: expert
  prompt: "Complète et approfondis ce rapport."
  context: { rapport_initial, domaine }

OpenProse résume automatiquement le contexte quand plusieurs variables volumineuses sont passées à un agent — cela évite de dépasser la fenêtre de contexte du modèle tout en préservant les informations essentielles.

Exemple concret

Voici un programme complet qui illustre l'usage combiné de parallel et loop until pour produire un rapport itératif de qualité croissante.

# 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."

Déroulement de l'exécution :

1. Le runtime instancie les agents analyste et ecrivain.
2. Le bloc parallel lance deux sessions analyste simultanément — l'une collecte des statistiques, l'autre des références bibliographiques.
3. Quand les deux sessions sont terminées, les variables donnees et references sont disponibles.
4. Le loop until démarre : à chaque itération, ecrivain rédige ou améliore la synthèse.
5. Après chaque itération, le modèle évalue si la condition **"synthèse acceptée"** est remplie.
6. Si oui, la boucle s'arrête. Sinon, elle recommence jusqu'à 3 fois maximum.

Ce pattern — collecte parallèle puis raffinement itératif — couvre la majorité des pipelines de production de contenu ou d'analyse documentaire.

Bonnes pratiques

Formuler des conditions IA précises

Les conditions **en gras** sont la force d'OpenProse mais aussi son principal point de fragilité. Une condition vague comme **"c'est bien"** produira des évaluations inconsistantes. Préférez des critères mesurables : **"le texte dépasse 400 mots et inclut au moins 3 exemples concrets"**.

Toujours définir un max réaliste

Chaque loop until doit avoir un max: cohérent avec la tâche. Pour une révision de texte, 3 à 4 itérations suffisent généralement. Pour une vérification factuelle complexe, on peut monter à 5 ou 6. Au-delà, le gain marginal est faible et le coût en tokens augmente linéairement.

Nommer les variables de façon explicite

Les variables v1, res, tmp rendent les programmes difficiles à maintenir. Préférez rapport_brut, donnees_marche, sources_validees — des noms qui expriment le contenu et l'étape dans le pipeline. Consultez notre guide sur le pipeline de contenu multi-agents pour des conventions de nommage éprouvées.

Éviter les dépendances circulaires dans le context

Si l'agent A passe son résultat à l'agent B qui le passe à l'agent A dans une boucle, le contexte s'accumule et peut saturer la fenêtre du modèle. Nettoyez le contexte entre les grandes étapes du pipeline et limitez le nombre de variables passées simultanément.

Isoler les appels externes dans un try/catch

Toute session qui appelle un skill réseau (web-search, APIs externes) est susceptible d'échouer. Encapsulez ces sessions dans un try/catch avec un agent de repli qui peut travailler avec des données en cache ou des estimations.

Questions fréquentes

Quelle est la différence entre un agent et une session en OpenProse ?

Un agent est une déclaration statique qui configure un acteur : modèle LLM, outils disponibles et instructions système. Une session est une invocation dynamique de cet agent pour accomplir une tâche précise. On peut comparer l'agent à la définition d'une fonction et la session à son appel — avec des arguments différents à chaque fois.

Comment OpenProse évalue-t-il les conditions en gras comme **"synthèse acceptée"** ?

Après chaque itération d'un loop until ou avant un bloc if, le runtime soumet la condition (en langage naturel) au modèle LLM avec le contexte courant du programme. Le modèle répond par vrai ou faux selon son évaluation sémantique. C'est une différence fondamentale avec les langages classiques : la condition n'est pas une expression calculable, c'est un jugement.

Peut-on réutiliser le même agent dans plusieurs sessions parallèles ?

Oui. Un agent déclaré une fois peut être invoqué dans autant de sessions que nécessaire, y compris dans un bloc parallel. Chaque invocation est indépendante — l'agent ne partage pas d'état entre les sessions.

Que se passe-t-il si le max: d'un loop until est atteint sans que la condition soit vraie ?

Le programme continue son exécution avec la dernière valeur des variables produites par la boucle. Il n'y a pas d'erreur levée par défaut. Pour gérer explicitement ce cas, encapsulez le loop until dans un try/catch ou ajoutez un if après la boucle pour vérifier la qualité du résultat.

Comment partager des données entre deux branches d'un bloc parallel ?

Ce n'est pas possible pendant l'exécution du parallel — les branches sont strictement indépendantes. Le partage se fait après la fermeture du bloc, quand toutes les variables sont disponibles dans le contexte global du programme.

Articles liés

Pour aller plus loin avec OpenProse, explorez nos ressources complémentaires. Le guide complet OpenProse pose les bases conceptuelles et vous guide de l'installation à votre premier programme. Pour une mise en pratique immédiate, notre tutoriel agents parallèles avec OpenProse démontre comment structurer des pipelines multi-agents performants avec des exemples de production réels.

---

Syntaxe maîtrisée ? Passez à la pratique avec notre tutoriel agents parallèles avec OpenProse.