BPMN diagram forming the spine of an enterprise process

From diagrams on the wall to logic in production

Most organizations already have process diagrams somewhere: on whiteboards, in Visio files, or in consulting slide decks. They describe how work should flow – at least in theory. But there is usually a huge gap between those diagrams and what actually runs in production systems.

Executable intelligence closes this gap. Instead of treating process diagrams as visual decoration, we treat them as the source of truth for automation. BPMN, DMN and CMMN models become inputs to an execution engine and to AI agents, not just artefacts in a project folder.

BPMN: the spine of your workflows

BPMN (Business Process Model and Notation) captures the end-to-end flow of work: activities, gateways, events and handovers between humans and systems. In Algomation, BPMN plays three key roles:

It defines the orchestration – the order in which tasks are executed.
It shows responsibility – which lanes and roles are involved.
It exposes integration points – where services and AI agents are called.

Instead of hand-coding these flows, we interpret the BPMN model directly. When combined with UAPF, a complete process (including its decisions and cases) can be exported as a single package and deployed across environments.

Figure 1. BPMN provides the backbone of the process; DMN and CMMN plug into it.

DMN: decisions as first-class citizens

In many organizations, decisions are buried in “if-else” statements in code or in spreadsheets that only one person understands. DMN (Decision Model and Notation) elevates decisions to first-class citizens.

Instead of opaque rules, business users see:

Decision requirement diagrams – how decisions depend on data and other decisions.
Decision tables – explicit conditions and outcomes, with clear hit policies.

For AI, this is transformative. Agents no longer guess the rules – they call a DMN decision service, pass structured inputs and receive a deterministic, explainable outcome. When the business changes its policy, it updates the DMN model; the AI agent automatically follows the new logic.

CMMN: embracing exceptions and human judgment

Not everything fits into a straight-through process. Investigations, disputes, complex customer requests – these are cases, not simple workflows.

CMMN (Case Management Model and Notation) models these situations explicitly. It allows tasks to be triggered by events and milestones, rather than a fixed sequence. Human judgment is built into the model:

Case workers can decide which tasks to activate.
AI agents can suggest next steps but do not control the whole flow.
Compliance can still see a structured representation of what happened.

By combining BPMN with CMMN, Algomation supports both predictable flows and unpredictable, high-value cases within a unified execution environment.

UAPF: one package to rule them all

UAPF (Unified Algorithmic Process Format) is the container that brings everything together. A single UAPF file can include:

BPMN diagrams for the main process flows,
DMN models for automated decisions,
CMMN models for exception handling and cases,
metadata, documentation and test scenarios.

This has two powerful consequences:

Portability. A model set can be moved between environments – dev, test, prod, or even different organizations – without losing context.
AI-friendliness. AI agents can load a UAPF package as a “skill bundle”, inspect its models and call its operations via APIs.

How AI agents use executable intelligence

Once processes are algorithmated, AI agents stop improvising and start collaborating. A typical pattern looks like this:

The agent receives a natural-language request (e.g. from a customer).
It maps the request to a BPMN process defined in UAPF.
At decision points, it calls DMN tables rather than guessing a response.
For complex situations, it opens a CMMN case and supports a human case worker.

The result is a hybrid model: humans, systems and AI agents all operate on the same explicit logic, instead of each interpreting policy in their own way.

A concrete implementation of this pattern for a retail credit process is described in From Algorithmated Credit to AI Agents , where a UAPF package is exposed as MCP tools.

That is what we call the journey from processes to executable intelligence.

Two concrete UAPF + MCP implementations are documented in From Algorithmated Credit to AI Agents and From Algorithmated Permits to AI Agents .

For a broader view on how UAPF scales from single workflows to an enterprise-wide algorithm layer, see From Single Processes to the Algorithmated Enterprise .