Pragmos: A Process Agentic Modeling System

1. Énoncé du problème

L'article aborde le défi de l'automatisation de la modélisation de la gestion des processus métier (BPM) à l'aide de modèles de langage (LLM). Bien que les outils existants (par exemple, ProMoAI, BPMN-Chatbot) tentent de générer des modèles de processus directement à partir de descriptions textuelles, ils souffrent de limitations critiques :

• Nature de boîte noire : La plupart des outils reposent sur des représentations internes opaques (par exemple, du code Python généré ou des formalismes comme POWL) que les analystes humains ont du mal à comprendre, valider ou affiner.
• Limites du raisonnement : Les LLM ont souvent du mal avec les dépendances logiques complexes, ce qui entraîne des erreurs dans le flux de contrôle (par exemple, des interblocages, des boucles incorrectes ou une concurrence manquée).
• Absence de contrôle itératif : Les approches actuelles traitent souvent la modélisation comme une tâche de génération en une seule étape, ne parvenant pas à soutenir l'affinement conversationnel et incrémental requis pour les processus complexes.

Les auteurs soutiennent que la modélisation de processus est intrinsèquement complexe et nécessite un flux de travail interactif et ouvert où humains et LLM collaborent, avec une transparence totale sur les étapes intermédiaires et la justification.

2. Méthodologie : L'approche Pragmos

Pragmos est un système prototype qui opérationnalise une approche hybride et agentique. Au lieu de demander à un LLM de générer un modèle BPMN final en une seule fois, Pragmos décompose la tâche en un pipeline structuré et multi-étapes. Il combine la compréhension du langage naturel des LLM avec des méthodes formelles rigoureuses issues de l'extraction de processus (spécifiquement les relations comportementales et la décomposition modulaire).

Flux de travail principal

Le système traite une description textuelle selon les étapes suivantes :

A. Étapes élémentaires (Découverte incrémentale)

1. Découverte des chemins d'exécution : Le LLM est invité à extraire des chemins d'exécution linéaires du texte, avec l'instruction explicite d'éviter de réentrer dans les boucles (traitant les boucles comme des itérations uniques pour l'instant).
2. Synthèse des relations comportementales :
   • Causalité et Conflit : Le système construit un Graphe de Suivi Direct (DFG) à partir des chemins, puis le transforme en un Graphe de Relations d'Ordre (ORG). Ce graphe définit explicitement :
     • Causalité ($a < b$) : $a$ doit précéder $b$.
     • Conflit ($a \# b$) : $a$ et $b$ sont mutuellement exclusifs.
     • Concurrence ($a \parallel b$) : $a$ et $b$ peuvent se produire dans n'importe quel ordre ou en parallèle.
   • Décomposition modulaire : L'ORG est décomposé en un Arbre de Décomposition Modulaire (MDT) à l'aide d'algorithmes en temps linéaire. Cet arbre identifie des blocs structurels (séquences, blocs parallèles, choix exclusifs).
   • Génération BPMN : L'MDT est parcouru pour générer un modèle BPMN préliminaire (en utilisant l'Algorithme 1).
3. Affinement de la concurrence : Un deuxième passage du LLM identifie spécifiquement des paires d'activités pouvant s'exécuter en parallèle, qui sont ensuite injectées dans l'ORG pour mettre à jour l'MDT et affiner le modèle.
4. Découverte des boucles : Le LLM identifie des blocs d'activités formant des boucles. Le système annoté l'MDT pour convertir des modules spécifiques en structures de boucle (initialement sous forme de boucles de répétition).

B. Traitement avancé (Abstraction et Correction)

• Abstraction de bloc : Pour les boucles complexes qui brisent l'hypothèse d'acyclicité de l'ORG, le système utilise l'abstraction pour modulariser le processus.
• Résolution des enchevêtrements structurels : Le système traite les "topologies de flux de contrôle" où la découverte standard échoue (par exemple, causalité manquante due à des relations transitives ou types de boucles incorrects comme while vs repeat).
  • Mécanisme : Il effectue un alignement par exécution symbolique. Il compare les chemins d'exécution originaux avec l'MDT du modèle généré.
  • Correction : Si un chemin saute le corps d'une boucle, le système convertit une boucle repeat en boucle while. Si des activités manquent, il introduit des "activités invisibles" (nœuds fantômes) pour résoudre les conflits et imposer une causalité correcte.

3. Contributions clés

1. Flux de travail transparent et explicable : Contrairement aux générateurs de boîte noire, Pragmos produit des artefacts intermédiaires intuitifs (chemins d'exécution, ORG, MDT) à chaque étape. Cela permet aux analystes humains d'inspecter, de questionner et d'affiner le modèle avant la génération du BPMN final.
2. Architecture hybride : Il intègre avec succès les capacités des LLM (compréhension du texte) avec la théorie formelle de l'extraction de processus (relations comportementales, décomposition modulaire, synthèse de réseaux de Petri). Cela garantit que les modèles résultants sont "sains" (logiquement cohérents) plutôt que simplement statistiquement probables.
3. Système de modélisation agentique : Pragmos agit comme un agent qui gère une conversation itérative avec état, décomposant les tâches de modélisation complexes en sous-tâches gérables plutôt que d'essayer une génération monolithique.
4. Gestion des topologies complexes : Le système introduit des mécanismes spécifiques pour résoudre les échecs courants des LLM, tels que la distinction entre les boucles courtes et la concurrence, et la correction des types de boucles (repeat vs while) via un alignement symbolique.

4. Résultats et évaluation

• Jeu de données : Le système a été évalué à l'aide du jeu de données PET, un benchmark bien connu contenant 45 descriptions de processus de complexité variable.
• Performance :
  • Pragmos a généré avec succès des modèles BPMN sains et corrects pour la majorité des cas.
  • Les modèles générés ont capturé avec précision la logique décrite dans les documents.
• Limitations :
  • Longueur du contexte : Le système a eu des difficultés avec des descriptions de processus extrêmement volumineuses (par exemple, "doc-4.1") où le nombre d'activités dépassait la fenêtre de contexte du LLM, même avec des techniques d'abstraction.
  • Types de boucles : Les générations initiales produisaient parfois des boucles repeat là où des boucles while étaient requises, nécessitant l'étape de correction symbolique décrite dans la méthodologie.

5. Signification

L'article représente un changement significatif dans la modélisation de processus assistée par l'IA :

• De l'automatisation à la co-conception : Il s'éloigne de l'objectif de génération entièrement autonome pour adopter un paradigme humain-dans-la-boucle. En exposant le "pourquoi" et le "comment" de la construction du modèle (via des artefacts intermédiaires), il permet aux analystes métier de rester aux commandes.
• Combler le fossé : Il démontre que les LLM peuvent être utilisés efficacement dans des domaines d'ingénierie à haut risque si leurs sorties sont contraintes et validées par des algorithmes formels et spécifiques au domaine.
• Orientation future : Les auteurs identifient le besoin d'études empiriques avec des analystes humains pour valider l'utilisabilité du flux de travail et de recherches sur la gestion de fenêtres de contexte plus larges pour les processus d'entreprise complexes.

En résumé, Pragmos offre un cadre robuste pour générer des modèles de processus métier fiables en combinant la flexibilité des LLM avec la rigueur mathématique de l'extraction de processus, garantissant que les modèles résultants sont non seulement syntaxiquement corrects, mais aussi sémantiquement alignés avec l'intention humaine.