Why BPMN (Still) Matters - Especially in the Age of AI

This post was originally published on the Camunda blog: Why BPMN (Still) Matters - Especially in the Age of AI.

Every few months, a new headline declares that “BPMN is dead” and that agentic AI will replace traditional process modeling entirely. The argument sounds compelling: if autonomous agents can negotiate and coordinate work in milliseconds, why would we still need process diagrams and orchestration engines?

But that framing misses something essential: AI can decide what to do next, but orchestration is what makes it executable safely, repeatedly, and at scale. Agents are great at ambiguity. Enterprises still have to run work with process state, controls, audit trails, retries, SLAs, and clear ownership when things go wrong. That is where BPMN still matters.

If AI is the brain, orchestration is the nervous system required to make the muscles move in a coordinated way.

The hard problems of enterprise automation have not magically changed with AI. Before you can automate work, you need to understand how it works and where it should go. Then comes execution with its own demands:

• A reliable runtime for complex workflows
• Long-running journeys (weeks or months)
• Operational control when things go wrong
• Business-level observability for AI-driven processes
• Governed evolution of production systems

These are exactly the problems a BPMN-based orchestration engine solves.

In the age of AI, we are moving beyond deterministic routing between systems toward agentic orchestration: a runtime that combines dynamic reasoning (agents deciding in ambiguous situations) with deterministic control (state, retries, SLAs, governance) so organizations can safely give AI real operational responsibility.

Modern enterprise automation needs both:

• Deterministic orchestration: explicit steps, state, timers, retries, error handling, and compliance-ready execution semantics
• Dynamic reasoning: agents that interpret context, handle ambiguity, and decide what to do next

You want AI where the work is fuzzy and variable, and deterministic control where work is very structured or must be reliable, auditable, and operable.

The opportunity is not BPMN or agents, but BPMN and agents.

Camunda’s 2026 State of Agentic Orchestration and Automation report found that 71% of organizations use AI agents, yet only 11% of agentic use cases reached production in the last year. The journey from pilot to production is longer and harder than expected not because agents cannot do the work, but because coordinating them safely at scale requires orchestration.

The missing piece in agent architectures: orchestration

When people say “BPMN is outdated,” they often mean BPMN diagrams look old school. But BPMN is more than a picture.

Behind the boxes and arrows lies a precisely defined execution semantics. In addition to rendering diagrams, a BPMN engine executes them. It becomes the runtime that:

• Tracks process state
• Manages transitions and timers
• Enforces transaction boundaries
• Handles retries, errors, and compensation
• Coordinates parallel paths and joins

Because it executes, it knows what happened, when, how long it took, which path was taken, and who was involved. You get full execution history and performance data automatically.

Agent frameworks, by contrast, focus on reasoning:

• Deciding what to do next
• Choosing which tools to call
• Interpreting instructions in natural language

Using these capabilities without coordination is a risk. Orchestration is what lets you hand AI real authority over your operations while still enforcing deterministic guardrails where needed.

BPMN for developers: executable state, not diagramming ceremony

A lot of developer skepticism toward BPMN comes from how it has been used: diagram-first processes, heavy modeling ceremonies, and boxes and arrows that feel far removed from production code.

But that is not how modern teams need to use BPMN.

Rather than simply “a diagram,” think of BPMN as an executable orchestration contract: a stateful runtime model that makes coordination explicit and operable. Treated properly, BPMN is code-adjacent. For example, it is:

• Versioned in Git
• Reviewed like any other change
• Tested through automated unit or integration tests
• Deployed alongside services
• Observable in production with instance state and history

The alternative is usually hidden coordination scattered across services, handlers, retries, queues, cron jobs, and ad hoc glue code, which is harder to test, harder to operate, and harder to govern.

The “AI will just generate orchestration code” argument

A related counter-argument in the AI era is: “We do not need orchestration engines. AI can simply generate the code.”

For simple flows, that may work. But once processes become nontrivial, complexity explodes. Generated code must handle retries, timeouts, long-running state, parallel execution, versioning, monitoring, and auditability. These are recurring structures, not edge cases.

At that point, you are no longer generating glue code; you are rebuilding an orchestration engine piecemeal across applications.

AI can generate code. But generating and operating a reliable process runtime across an enterprise is a different problem.

A real example: loan origination with outside and inside orchestration

To make this concrete, consider loan origination at a bank.

At the top level (outside orchestration), BPMN defines the complete customer journey:

1. Receive loan request
2. Fraud check
3. Loan offer preparation (AI agent interaction)
4. Underwriting
5. Human approval
6. Send official offer
7. Wait for signature (with reminders and expiry)
8. Disburse loan

This is orchestration from the outside: BPMN controls sequence, long-running state, timeouts, and mandatory gates.

Now zoom into the loan offer preparation agent (inside orchestration). The agent can converse with customers and decide how to use tools, but each tool call is itself orchestrated by BPMN guardrails.

Examples:

• Specialist handoff becomes a structured human task the agent cannot bypass.
• Customer messages can be routed through human review based on confidence.
• Structured subprocesses (credit check, risk assessment, terms calculation) remain deterministic and auditable.

The same orchestration engine handles both the outer journey and the agent’s tool-access guardrails.

One model, shifting along the autonomy spectrum

BPMN naturally supports a spectrum of autonomy in one model:

• Fully deterministic steps
• Hybrid steps (agent proposes, rules or humans confirm)
• Fully agentic steps (within guardrails)

This is not a one-time decision. Teams can dial autonomy up or down over time based on real execution data, without rebuilding the whole flow.

Long-running processes meet fast-changing AI

AI evolves rapidly: new models, prompts, policies, and regulations. Enterprise processes are often long-running, with many in-flight instances.

Operational questions become critical:

• Which agent version was used?
• How do we upgrade process definitions safely?
• How do we handle in-flight instances?
• Can we prove what logic applied to a decision months ago?

A mature BPMN orchestration engine handles this through:

• Versioned processes
• Governed migration
• Complete audit trails

This is where BPMN becomes a governance backbone, not just a diagramming standard.

You cannot operate what you cannot see

Giving agents work is easy. Operating them is hard.

A BPMN-based orchestration engine provides a single operational lens where every piece of work is a process instance with clear lifecycle, context, and intervention points.

Teams can:

• Detect stuck instances and SLA risks
• Retry, reroute, pause, or escalate safely
• Measure cycle times and bottlenecks
• Explain outcomes in business language

Without orchestration, teams end up reconstructing cross-system behavior from log fragments.

AI will help build orchestration, too

AI also makes orchestration easier to build:

• Draft executable BPMN models from natural language
• Suggest model improvements
• Generate integration code for service tasks
• Explain complex models

Instead of replacing orchestration, AI can accelerate it while the runtime remains standardized, operable, and governed.

Recap

If all BPMN did was static diagramming, it would be insufficient for the age of AI. But that is a false dichotomy.

The real opportunity is BPMN and agents. Deterministic and dynamic. Guardrails and autonomy.

In practical terms, that means:

• Use BPMN to orchestrate end-to-end flows across people, systems, and agents
• Let agents handle unstructured reasoning tasks inside those flows
• Inject mandatory guardrails between the agent’s brain and its tools
• Move steps along the autonomy spectrum as you learn
• Use orchestration strengths where AI is weakest: long-running state, operations, monitoring, versioning, and governance

BPMN is not an artifact of a pre-AI world. It encodes hard lessons of running automation at scale.

Agentic AI makes orchestration more important, not less.

Try it in practice

• Start the discussion: forum.camunda.io
• Build it today: Install Camunda 8
• Ready to orchestrate: Start trial