Pragmos: A Process Agentic Modeling System

1. Problem Statement

The paper addresses the challenge of automating Business Process Management (BPM) modeling using Large Language Models (LLMs). While existing tools (e.g., ProMoAI, BPMN-Chatbot) attempt to generate process models directly from textual descriptions, they suffer from critical limitations:

• Black-Box Nature: Most tools rely on opaque internal representations (e.g., generated Python code or formalisms like POWL) that are difficult for human analysts to understand, validate, or refine.
• Reasoning Limitations: LLMs often struggle with complex logical dependencies, leading to errors in control flow (e.g., deadlocks, incorrect loops, or missed concurrency).
• Lack of Iterative Control: Current approaches often treat modeling as a single-step generation task, failing to support the incremental, conversational refinement required for complex processes.

The authors argue that process modeling is inherently complex and requires an open-ended, interactive workflow where humans and LLMs collaborate, with full transparency into the intermediate steps and rationale.

2. Methodology: The Pragmos Approach

Pragmos is a prototype system that operationalizes a hybrid, agentic approach. Instead of asking an LLM to generate a final BPMN model in one go, Pragmos decomposes the task into a structured, multi-step pipeline. It combines the natural language understanding of LLMs with rigorous, formal methods from process mining (specifically behavioral relations and modular decomposition).

Core Workflow

The system processes a textual description through the following stages:

A. Elementary Steps (Incremental Discovery)

1. Execution Path Discovery: The LLM is prompted to extract linear execution paths from the text, explicitly instructed to avoid re-entering loops (treating loops as single iterations for now).
2. Behavioral Relation Synthesis:
   • Causality & Conflict: The system constructs a Directly-Follows Graph (DFG) from the paths, then transforms it into an Ordering Relations Graph (ORG). This graph explicitly defines:
     • Causality ($a < b$): $a$ must precede $b$.
     • Conflict ($a \# b$): $a$ and $b$ are mutually exclusive.
     • Concurrency ($a \parallel b$): $a$ and $b$ can occur in any order or parallel.
   • Modular Decomposition: The ORG is decomposed into a Modular Decomposition Tree (MDT) using linear-time algorithms. This tree identifies structural blocks (sequences, parallel blocks, exclusive choices).
   • BPMN Generation: The MDT is traversed to generate a preliminary BPMN model (using Algorithm 1).
3. Concurrency Refinement: A second LLM pass specifically identifies pairs of activities that can run concurrently, which are then injected into the ORG to update the MDT and refine the model.
4. Loop Discovery: The LLM identifies blocks of activities that form loops. The system annotates the MDT to convert specific modules into loop structures (initially as repeat-loops).

B. Advanced Handling (Abstraction & Correction)

• Block Abstraction: For complex loops that break the acyclic assumption of the ORG, the system uses abstraction to modularize the process.
• Structural Entanglement Resolution: The system addresses "control flow topologies" where standard discovery fails (e.g., missing causality due to transitive relations or incorrect loop types like while vs. repeat).
  • Mechanism: It performs a symbolic execution alignment. It compares the original execution paths against the generated model's MDT.
  • Correction: If a path skips a loop body, the system converts a repeat loop to a while loop. If activities are missing, it introduces "invisible activities" (ghost nodes) to resolve conflicts and enforce correct causality.

3. Key Contributions

1. Transparent, Explainable Workflow: Unlike black-box generators, Pragmos produces intuitive intermediate artifacts (execution paths, ORGs, MDTs) at every step. This allows human analysts to inspect, question, and refine the model before the final BPMN is generated.
2. Hybrid Architecture: It successfully integrates LLM capabilities (text understanding) with formal process mining theory (behavioral relations, modular decomposition, Petri net synthesis). This ensures the resulting models are "sound" (logically consistent) rather than just statistically probable.
3. Agentic Modeling System: Pragmos acts as an agent that manages a stateful, iterative conversation, breaking down complex modeling tasks into manageable sub-tasks rather than attempting a monolithic generation.
4. Handling Complex Topologies: The system introduces specific mechanisms to resolve common LLM failures, such as distinguishing between short loops and concurrency, and correcting loop types (repeat vs. while) via symbolic alignment.

4. Results and Evaluation

• Dataset: The system was evaluated using the PET dataset, a well-known benchmark containing 45 process descriptions of varying complexity.
• Performance:
  • Pragmos successfully generated sound and correct BPMN models for the majority of the cases.
  • The generated models captured the logic described in the documents accurately.
• Limitations:
  • Context Length: The system struggled with extremely large process descriptions (e.g., "doc-4.1") where the number of activities exceeded the LLM's context window, even with abstraction techniques.
  • Loop Types: Initial generations sometimes produced repeat loops where while loops were required, necessitating the symbolic correction step described in the methodology.

5. Significance

The paper represents a significant shift in AI-assisted process modeling:

• From Automation to Co-Design: It moves away from the goal of fully autonomous generation toward a human-in-the-loop paradigm. By exposing the "why" and "how" of the model construction (via intermediate artifacts), it empowers business analysts to remain in control.
• Bridging the Gap: It demonstrates that LLMs can be effectively used in high-stakes engineering domains if their outputs are constrained and validated by formal, domain-specific algorithms.
• Future Direction: The authors identify the need for empirical studies with human analysts to validate the usability of the workflow and research into handling larger context windows for complex enterprise processes.

In summary, Pragmos offers a robust framework for generating reliable business process models by combining the flexibility of LLMs with the mathematical rigor of process mining, ensuring that the resulting models are not only syntactically correct but also semantically aligned with human intent.