From Process Models to Composable Agentic Workflows: Combining BPMN, Agents and Enterprise Knowledge

Christian Fillies, Jan Fillies, Frauke Weichhardt, Gay Anne Wood-AlbrechtarXiv 2026 · arXiv

TL;DR

This paper introduces a framework for taming the complexity of multi-agent systems by using Business Process Model and Notation (BPMN) as an explicit orchestration layer. By transforming BPMN models into executable LangGraph workflows, the authors enable "Recursive Capability Composition," where agents and entire business processes can be wrapped as reusable tools for one another, grounded in structured enterprise knowledge.

What Problem Does This Paper Address?

As LLM-based agents move from simple chat interfaces to complex multi-agent systems, they often suffer from a "visibility crisis." In many current implementations, the workflow logic is implicit—buried deep within prompts, tool-calling loops, and application code. This makes these systems incredibly difficult to monitor, debug, or optimize at an enterprise scale.

Furthermore, general-purpose LLMs lack the "organizational DNA" of a specific company. While Retrieval-Augmented Generation (RAG) helps, it often treats documentation as flat text. Agents need to understand not just what information exists, but the structured relationships of how an organization actually operates—its specific roles, decision logic, and activity sequences.

Methods

The authors propose a model-driven approach using SemTalk, a tool that bridges the gap between high-level process modeling and low-level agent execution.

  1. BPMN to LangGraph Transformation: The core technical contribution is a mapping of standard BPMN 2.0 elements to a LangGraph/Pregel runtime. This ensures that the visual process model isn't just documentation—it is the code.
  2. Gateways (XOR/AND) become deterministic routing functions.
  3. Data Objects map to a shared, thread-safe state schema.
  4. Tasks are implemented as either deterministic code (Script Tasks) or LLM-backed nodes (Agentic Tasks).
Mapping BPMN elements to LangGraph runtime mechanics
  1. Agentic Tasks & Participants: The framework introduces "Agentic Tasks," where the when and what are defined by the BPMN flow, but the how is left to an LLM's reasoning. "Agentic Participants" act as reusable interfaces, allowing an agent to call another agent—or an entire sub-process—as if it were a simple tool.
  2. Model Context Protocol (MCP): The system uses MCP to externalize these process-backed capabilities, allowing external agents to discover and invoke enterprise functions without needing to understand their internal complexity.

Datasets

Not discussed in the paper. The work focuses on architectural patterns and the transformation logic between modeling languages and execution runtimes rather than empirical training or benchmarking on specific datasets.

Key Insights and Ideas

  • Recursive Capability Composition: This is the "aha" moment of the paper. Because both agents and BPMN processes are exposed through the same tool interface, the system is naturally recursive. A process can invoke an agent, which can call a tool, which triggers another complex business process.
  • BPMN as a Guardrail: By keeping deterministic logic (like "if total > $1000, require human approval") in the BPMN layer, the authors reduce the "hallucination surface" of the LLM. The agent only reasons where flexibility is actually required.
  • Process Models as Knowledge Graphs: The authors argue that a BPMN model is a structured source of truth. When an agent is performing a task, it can be fed the "Process Context"—knowing its predecessors, successors, and the business objects involved—to make better-informed decisions.
Figure 1: BPMN Process with sequential Activities and a Gateway

Key Results

The paper provides a qualitative proof-of-concept for a model-driven agentic architecture.

  • Structural Visibility: By using BPMN, developers and business operators share a single, executable view of the agentic workflow, facilitating easier debugging and monitoring.
  • Execution Mechanics: The authors successfully mapped complex BPMN behaviors, such as parallel forking and joining (AND gateways), to the Pregel "superstep" barrier mechanism in LangGraph, ensuring execution correctness.
Mapping of flow control elements

Limitations and Future Work

While the architectural foundation is solid, the authors acknowledge several hurdles for production-grade deployment:

  • Scalability & Validation: Systematic evaluation of the BPMN-to-LangGraph transformation across a wider variety of complex, real-world processes is still required.
  • Probabilistic Governance: While BPMN constrains when an agent is called, it cannot yet guarantee the correctness of the agent's output. Integrating concepts like "uncertainty" and "trust" directly into the process model is a key area for future research.
  • Security: Composable workflows introduce complex requirements for authorization and auditing, especially when an autonomous agent can trigger processes that interact with sensitive legacy systems or human actors.

Summary updated

Abstract

LLM-based agents can reason, use tools and collaborate. However, coordinating increasingly complex agentic applications becomes difficult to understand, monitor and improve. Decisions distributed across prompts, tool calls and application logic make workflows implicit. We introduce **Recursive Capability Composition**, enabling agents to execute business processes and expose them as reusable Agentic Tools. This paper presents a BPMN-based approach to Agentic Workflows, combining explicit orchestration with autonomous reasoning. SemTalk BPMN models are transformed into executable workflows using a LangGraph/Pregel runtime. Agentic Tasks introduce LLM reasoning at selected activities, while conventional BPMN controls process flows, deterministic decisions, system interactions and human approvals. Agentic Participants provide reusable interfaces for agent behavior or other executable processes. BPMN orchestration makes multi-agent systems more understandable and manageable. Explicit process models provide developers and operators with a shared view of workflow structures and execution progress, facilitating debugging, monitoring and optimization. Enterprise agents also need organization-specific context. Process Models and Knowledge Graphs describe activities, participants, information objects, decisions and relationships between processes. They provide structured knowledge of how an organization operates, supporting informed agent decisions and actions. Our contributions are threefold: 1. **Model-Driven Execution:** Transforming BPMN models into executable Agentic Workflows. 2. **Recursive Capability Composition:** Exposing agents and executable business processes as reusable tools for other agents. 3. **Enterprise Context:** Using Process Models and Ontologies to provide organization-specific knowledge for agent reasoning.
BibTeX
@misc{fillies2026from,
  author = {Christian Fillies and Jan Fillies and Frauke Weichhardt and Gay Anne Wood-Albrecht},
  title = {{From Process Models to Composable Agentic Workflows: Combining BPMN, Agents and Enterprise Knowledge}},
  year = {2026},
  eprint = {2611.13196},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.13196},
}
Figure