From Process Models to Governed Agentic Workflows
BPMN, workflow engines and process mining still do the work they were built for. None of them was built to say what an agent may decide, on what context, or what it must leave behind.
Written as at 1 October 2026.
For: enterprise architects, BPM and automation leads, and anyone who has been asked whether the process estate survives agents. The decision: what to keep, what to stop expecting it to do, and what has to be built beside it.
A reasonable objection gets raised in every one of these conversations, usually by the person who has run the automation programme for a decade. We already have BPMN. We have an engine. We have process mining telling us what actually happens. Why is any of this new?
It is a good objection and it deserves a precise answer rather than a slide. The honest one has three parts. Most of what that estate does still works and should be kept. One part of it rests on an assumption that agents quietly break. And the controls that agents actually need were never in scope for any of it – not as an oversight, but because nobody was building for a participant that decides what to do next.
What the last twenty-five years actually built
Start with what is true, because the case for anything new is worthless if it misrepresents what is already there.
BPMN is a settled, mature notation. Version 2.0.2 was published by the Object Management Group in January 2014 and nothing has formally superseded it since – no 2.1, no 3.0, twelve years on. That is usually read as stagnation. It is at least as reasonable to read it as a notation that finished. Its stated goal was to be “readily understandable by all business users”, from analysts through developers to the people who manage the process, and on that goal it won: it is the lingua franca in which a regulator, an architect and a business owner can look at the same picture and argue about the same thing.
It is also used far more narrowly than it is specified. zur Muehlen and Recker examined 120 BPMN diagrams and found that less than 20% of the vocabulary is used regularly, with the average model drawing on about nine distinct constructs. The useful reading is not that practitioners are lazy. It is that the subset which survives contact with real modelling is small, stable and expressive enough – and that subset is exactly the part that still applies.
DMN is alive and still moving. Version 1.6 was published in September 2026 and a 1.7 beta is out, which makes it one of the few parts of this estate under active development. It separates decision logic from process flow, gives it a notation and an expression language, and defines three conformance levels – the lowest of which does not require the model to be executable at all. One detail matters more than it looks: DMN is documented as compatible with Java, PMML and ONNX. A decision model can already call a trained model as a piece of its logic. The boundary between deterministic decisioning and statistical inference was drawn, carefully, years ago.
CMMN, honestly, is dormant. Version 1.1 dates from December 2016 and nothing has followed. Camunda – one of its most significant implementers – said publicly in 2020 that it would stop adding CMMN features, that “when compared in the wild people found that BPMN was simply better than CMMN”, and that its authors had removed the CMMN chapter from their textbook. Camunda 8 supports BPMN and DMN only. Flowable still implements CMMN 1.1 but documents several of its own extensions as departures from the specification.
This matters because CMMN was the standard built for precisely the thing agents do: work that is not a fixed sequence, where what happens next depends on what was found. The notation designed for unstructured work did not take. Where case-like flexibility actually landed, a decade later, is the BPMN ad-hoc sub-process – a region of a model where the order is not prescribed. Hold that thought; it returns.
Durable execution engines solved the hard part of distributed work, and they are not interchangeable. What each one actually guarantees, from its own documentation:
| Engine | Execution semantics | Determinism required of your code | Compensation | In-flight version change |
|---|---|---|---|---|
| Temporal | Activities may run more than once; docs say “always make your business logic Activities idempotent” | Yes – same API calls in the same sequence, or use versioning | A code pattern; Java SDK ships a Saga helper |
Worker Versioning (pinned or auto-upgrade), or patching |
| Camunda 8 | “Zeebe uses the at-least-once strategy for job handlers” | No – BPMN is model data the engine interprets | First-class, via BPMN compensation events | Process instance migration, with a long list of restrictions |
| AWS Step Functions (Standard) | “Exactly-once workflow execution” | No – declarative JSON | A documented pattern, not a feature | Immutable versions and aliases |
| Azure Durable Functions | Not stated explicitly in the pages reviewed | Yes – a long list of constraints, including no DateTime.Now and no Guid.NewGuid() |
A pattern; the audit trail “support[s] reliable compensating actions” | Orchestration Versioning, built in |
Two things in that table are worth reading twice. First, only Step Functions Standard claims “exactly-once”, and the claim is scoped to the workflow execution, not to the side effects of its tasks. Nothing in any of these products makes a payment happen exactly once; your handler does that, with an idempotency key, or it does not happen. Second, the determinism requirement splits the field in half, and that split turns out to decide where an agent is allowed to sit.
Process mining is the most rigorous thing in the estate. Its foundation is narrow and strong: an event log needs, at minimum, a case identifier, an activity and a timestamp. From that you get discovery, conformance checking and performance analysis. Conformance in particular is a real science – van der Aalst describes alignments as “the gold standard” because they produce the path through the model closest to what was actually observed, and quality is judged on four dimensions at once: fitness, precision, generalisation and simplicity. There are standards underneath it: IEEE 1849 (XES) for event logs, revised in 2023, and OCEL 2.0 for object-centric logs, published in October 2023.
None of this is legacy. All of it should survive the transition.
The assumption that breaks
Everything above shares one premise, and it is so deep that it is rarely stated: the model comes first and the execution is measured against it.
A BPMN diagram is a prescription. The engine enforces it. Process mining compares what happened to it. Conformance checking is, definitionally, the distance between an observed trace and a reference model. The whole apparatus is a loop around a plan that existed before the work did.
An agent inverts that. The path is chosen at runtime, from context the modeller did not have, and it may be a path nobody drew. This is not a failure of the agent; it is the capability being bought. But it means several things stop working the way they did:
Conformance to what? If no reference model prescribes the path, conformance checking has nothing to align against. The technique is not wrong – it is unanchored. The answer is not to abandon it but to move what it checks: not did the run follow the drawn path, but did the run hold the invariants. That is a smaller, harder and much more useful question, and it is the subject of agentic flow mining.
What is the case identifier? The minimal event log needs one case id per trace. An agent that spawns subagents, retries a step four times against two different tools and hands part of the work to a person does not produce one clean case. It produces an object graph. This is exactly the problem OCEL 2.0 was built for – object-to-object relationships, attributes that change over time, and qualifiers on relationships. The object-centric event log is not a nice-to-have for agentic work. It is the only log shape that fits it.
Determinism becomes an architectural constraint, not a style note. Temporal requires workflow
code to make the same API calls in the same sequence on replay. Azure Durable Functions forbids
DateTime.Now and Guid.NewGuid() inside an orchestrator for the same reason. A language model
call is the least deterministic thing in your system. The rule that follows is concrete and
non-negotiable: the model call is an activity, never an orchestrator. Put inference inside
replayed workflow code and the first replay after a worker restart will diverge, silently, in
production, in a way that is extremely unpleasant to debug. On Camunda 8 and Step Functions the
constraint does not arise in the same form, because the process definition is declarative data
rather than replayed code – which is a genuine architectural argument for a BPMN engine in an
agentic system, and one I have not often heard made.
The controls none of them supply
Here is the part that is not a gap in anyone’s implementation. It is a gap in scope. These standards were specified for a world in which the thing executing a step was a service, a script or a person with a job title – not a participant that interprets, plans and chooses.
Authority is not a lane. BPMN has pools and lanes, and they describe who performs an activity. They do not describe what a performer is permitted to commit, under whose delegation, narrowed how, and expiring when. A lane is an organisational label on a diagram; delegated authority is a runtime decision with attenuation and an expiry. Nothing in BPMN, DMN or CMMN models it, because for a human performer it lived in an access control system nobody drew. An agent makes that omission load-bearing – see delegation is not authority.
Context provenance is nowhere. BPMN models message flow, not data models – the OMG’s own material is explicit that data modelling is out of scope. So there is no place in any of these notations to state what an agent was permitted to know when it decided: which retrieval corpus, at what classification, under whose purpose. That is the Context Contract, and the reason it has to be declared and versioned is that it is the input nobody can reconstruct afterwards. “The agent decided X” is not reviewable without it; see context is not a prompt.
Evidence of rejection does not exist. An event log records what happened. For a deterministic process that is sufficient, because what happened was what the model said would happen. For an agent, the interesting record is what it considered and did not do – the three tools it could have called, the two it was refused, the action it proposed that policy declined. A trace with only the successful path is a record of the output, not of the decision, and it is the rejected branch that an auditor asks about.
Outcome is still missing. This is the oldest hole and agents make it expensive. Conformance tells you the run followed the rules. It does not tell you the action achieved what it was authorised to achieve. A system that proves what happened and never asks whether it worked is auditable and still wrong.
The research community has named the shape of this. The Agentic Business Process Management manifesto (March 2026) proposes APM as an extension of BPM in which “autonomy is constrained, aligned, and made operational through process awareness” – framed autonomy rather than replaced process. The term the vendors use, agentic process automation, has an academic origin too, in the 2023 ProAgent paper. What does not exist, as of October 2026, is a standard. There is no OMG specification for agent workflows, no BPMN 3.0, and nothing with the governance weight of DMN.
What there is, and it is not nothing: MCP (specification version 2026-07-28) now has a
Tasks extension that gives a tool call a durable handle with a lifecycle – working,
input_required, completed, failed, cancelled – so a long-running agent action survives a
client restart and can be polled, cancelled or fed more input. That is durable execution arriving
at the tool boundary, from the protocol side rather than the engine side. A2A 1.0.0 is
explicitly “async first” for long-running tasks with human-in-the-loop. Both sit under Linux
Foundation governance. Neither governs authority, and MCP says so plainly: it “cannot enforce these
security principles at the protocol level”.
The implementation path
Nothing here argues for replacing the estate. The sequence that works is additive, and each step is useful on its own.
1. Keep the model where the model earns its place. Draw the parts of the process that are genuinely prescribed – the regulated sequence, the segregation of duties, the compensation path – in BPMN, and keep them in an engine. Do not draw the agent’s reasoning. A diagram of a non-prescribed path is a lie that will be audited against.
2. Make the agent a region, not a replacement. Put the agentic part inside an ad-hoc sub-process: a bounded area where the order is chosen at runtime and the boundary around it is still modelled. The deterministic process keeps the commit boundary, the compensation and the escalation; the agent chooses within it. This is also, not coincidentally, where at least one engine vendor has landed.
3. Keep inference out of replayed code. The model call is an activity. If your engine replays workflow code, this is a correctness requirement, not a preference.
4. Make the boundary a service task. Every action that changes a system of record goes through one modelled step that checks context, authority and evidence before it commits. That step is deterministic, it is testable, and it is the thing you show a regulator. See the commit boundary.
5. Move the event log to an object-centric shape. Adopt OCEL-style logging before the volume arrives, not after. Retrofitting case identifiers onto an agent’s object graph is far harder than emitting the graph in the first place.
6. Re-point conformance at invariants. Stop checking whether the run matched a drawn path. Start checking whether it held the rules that must never break – no commit without authority, no context outside the contract, evidence written before the act.
7. Add the outcome record. Attach to each decision what it was meant to achieve, measure whether it did, and feed failures back into narrowing authority. Without this the other six steps produce a beautifully documented system nobody can improve.
Key takeaways
- BPMN is not obsolete; it is finished. No formal version since January 2014, and under 20% of its vocabulary in regular use – but that subset is stable, understood by business and regulator alike, and still the right way to draw a prescribed path.
- CMMN, the standard built for unstructured work, did not take. Its role was effectively inherited by the BPMN ad-hoc sub-process, which is where the agentic region belongs.
- No engine gives you exactly-once side effects. Only one product claims exactly-once at all, and it is scoped to the workflow execution. Idempotency is yours.
- The determinism requirement decides your architecture. Where workflow code is replayed, a model call must be an activity. A declarative engine avoids the problem differently, which is a real argument in its favour that rarely gets made.
- Conformance checking survives, but it must be re-pointed from “did it follow the path” to “did it hold the invariants”, because the path is now chosen at runtime.
- The object-centric event log is the only log shape that fits agentic work. One case id per trace does not survive subagents, retries and handoffs.
- Authority, context provenance, rejected-action evidence and outcome are out of scope for all of it – not missing by accident, but never specified, because none of these standards was written for a participant that decides.
Sources and further reading
- The Contextual Agentic Enterprise, Chapters 8, 12 and 24.
- Object Management Group (2014) Business Process Model and Notation (BPMN) 2.0.2, formal/13-12-09. https://www.omg.org/spec/BPMN/2.0.2/About-BPMN
- zur Muehlen, M. and Recker, J. (2008) ‘How Much Language Is Enough? Theoretical and Practical Use of the Business Process Modeling Notation’, CAiSE 2008.
- Object Management Group (2026) Decision Model and Notation (DMN) 1.6; 1.7 beta. https://www.omg.org/spec/DMN
- Deehan, N. (2020) ‘How CMMN never lived up to its potential’, Camunda, 20 August 2020.
- van der Aalst, W.M.P. (2022) ‘Process Mining: A 360 Degree Overview’, in Process Mining Handbook, LNBIP 448, Springer. Open access.
- Berti, A. et al. (2023) OCEL 2.0 Specification. arXiv:2403.01975.
- Calvanese, D. et al. (2026) ‘Agentic Business Process Management: A Research Manifesto’. arXiv:2603.18916.
- Ye, Y. et al. (2023) ‘ProAgent: From Robotic Process Automation to Agentic Process Automation’. arXiv:2311.10751.
- Engine documentation, read 1 October 2026: Temporal, Camunda 8, AWS Step Functions, Azure Durable Functions. Each guarantee in the table above is quoted from the vendor’s own pages.
This article is part of CAE Field Notes, a series accompanying the book, The Contextual Agentic Enterprise.
Related
The Commit Boundary: Where AI Recommendations Become Enterprise Consequences
Controls placed at the start of an agent conversation check the wrong thing. The decisive check evaluates the exact action about to become real, at the moment it becomes real.
A Model Can Recommend an Action. It Does Not Acquire Authority to Perform It
Directors ask whether their AI is safe. The better question is on whose authority it acts, because accuracy, confidence and technical access are not a delegation.
Agentic Flow Mining: Discovering How Agents Actually Work
Traces show that each step succeeded. They don't show whether the steps formed an acceptable process. Mining agent runs against invariants does.
Delegation Is Not Authority: Governing Multi-Agent Handoffs
When one agent hands work to another, authority should narrow, never widen. A delegated task must carry its origin and its limits, or it becomes a way to launder a prohibition.