Flowable: an open-source BPMN engine with an enterprise AI agent platform

In short: Flowable open source vs enterprise: the open-source engines run the processes, and the enterprise platform adds governed AI agents. Flowable's engines for processes, cases and decisions are free under the Apache 2.0 license, and its AI agents, the AI models that choose their next step and the tools they use, come with the Agentic Case Platform built on those same engines. Teams on the open-source engines can already call AI models from their processes, through steps they design themselves.

Updated 12 October 2026: rewritten to show what is open source in Flowable and what its agentic platform adds, with the comparison with Camunda, jBPM and Activiti brought up to date and Bizagi added.

This guide is for the technical and business process teams that want AI agents in their processes and are choosing between Flowable's open-source engines and its commercial platform. It separates the parts that are free from the parts that are licensed, explains how the engine runs a process and why that matters for agents, and compares Flowable with other process platforms and engines, Camunda, Bizagi, jBPM and Activiti, as of October 2026. Aplyca is a Flowable partner in Colombia and Latin America.

Flowable open source vs enterprise: free engines, with the agents in the platform

Flowable's engines are open source; its applications and its AI agents are commercial, the enterprise offering Flowable sells. The engines are written in Java and can be embedded in an application as a library or run as a server, with a REST API, an HTTP interface that offers the same operations as the Java API to applications written in any language. The latest open-source release published on GitHub is 8.0.0, from February 2026.

Each engine runs an open standard. Business Process Model and Notation (BPMN) describes processes, Case Management Model and Notation (CMMN) describes cases, and Decision Model and Notation (DMN) describes decision tables; Flowable says its engines fully support all three.

The commercial products are, in Flowable's words, "built on top of the Flowable Open Source project". Flowable delivers its AI features through that platform, while the open-source engines stay focused on running processes, cases and decisions, and can call any AI model that offers an API through standard process steps, shown below.

The open-source engine holds the process, which is why agents need it

The engine, not the application that started it, holds the process. In Flowable, a process instance, one run of a process, begins at its start event and runs until it reaches a wait state, such as a user task that a person must complete. There, the engine saves the state of the instance (which step it is on, the data it carries and who must act) in its database, and hands control back to the application that started it. While it waits, the instance uses no memory or processing, and it can wait for days, weeks or, as the documentation puts it, "even years if it has to be".

In a monthly financial report process: the process starts, reaches the task "Write monthly financial report" assigned to the accountancy group, and stops. The call that started it has already returned. In Flowable's words, "if the engine reboots or crashes in the meantime, the state of the process is safe and secure in the database." When someone completes the task, the engine resumes and runs to the next wait state, here the management review, then to the end.

Steps marked as asynchronous, which the engine runs later in the background instead of at once, work the same way: the engine stores them as jobs in the database, and its async executor runs them. A job that keeps failing is set aside in a dead-letter table for a person to inspect, instead of being lost.

As we see it, this is what makes an AI step governable. A call to an AI model can be slow, can fail or can return something a person must check. When that call is a step in a process, the engine retries it, records it and, where a person must decide, waits for them, with the state of the process safe in the database the whole time. The AI model answers; the process decides what happens next.

AI with the open-source engines: possible today, designed by the team

A team can call AI models from a process on the open-source engines today, designing the agent logic to fit its own needs. As we see it, the open-source building blocks are these, all from Flowable's BPMN documentation:

• The HTTP task sends a request to an API, such as an AI model provider's, and stores the response in process variables, the data the process carries. A response code chosen in advance can raise a BPMN error, which the diagram has a path for.

• The external worker task hands a step to an external worker: a program written in any language that takes the job, does the work, for example calling an AI model with the process's data, and completes it, with retries and the dead-letter table if it keeps failing. Flowable maintains worker clients for Java, TypeScript, Python, .NET and Go; they are documented with Flowable's trial, and a team on the open-source engine validates them in its own environment.

• The event registry starts or steers a process when a message arrives from another system, through messaging systems such as Kafka, RabbitMQ or Java Message Service (JMS).

• A user task after the AI step is the checkpoint where a person reviews or corrects the AI model's output before the process acts on it.

With this approach, the team keeps full control of the instructions to the AI model and the systems it may call, the checks on what it returns, and the monitoring of calls and their cost. For a few well-defined AI steps, it is a direct way to start. As the number of agents grows, the commercial platform provides that work ready to use, with guardrails, evaluators and cost tracking.

What Flowable's agentic platform adds: governed agents in the process diagram

The Agentic Case Platform adds AI agents as modeled, governed parts of processes and cases. Flowable introduced its agent engine in release 2025.1, in July 2025, and describes the platform as licensed separately from the open-source engines.

• An agent step in the diagram. The AI Agent Task is a task in a BPMN process or a CMMN case that calls an agent, which is defined separately with its instructions and tools. It has the settings of any engine step: it can run in the background, be retried, and turn an error into a BPMN error the diagram has a path for.

• Agent types. The documentation lists utility, orchestrator, knowledge, document, external, agent-to-agent (A2A), guardrail and evaluator agents. A knowledge agent draws on knowledge bases that Flowable fills from documents, for retrieval-augmented generation (RAG): the agent looks up the relevant passages before it answers.

• Guardrails, evaluators and costs. Release 2026.1, of 16 July 2026, added guardrails that check an agent's input and output, evaluators that score its results afterwards, and an Agent Operations dashboard that tracks calls, usage, cost and duration per agent and per AI model.

• MCP. The Model Context Protocol (MCP) lets AI assistants and agents use tools from other systems. With 2026.1, Flowable added MCP servers through which agentic applications can start processes and complete tasks. It also added a Design MCP server, off by default, through which AI assistants can read, edit and validate process diagrams with the user's own permissions.

• A2A. Since 2025.2, an A2A agent connects a process to agents on other platforms through the agent-to-agent protocol.

• People in the loop. When an agent on another platform needs more information, the agent step turns into a user task and calls the agent again once a person answers. Flowable says that on its platform "high-stakes actions always wait for a human". It proposes deciding step by step whether a person approves before an agent acts or supervises afterwards. The criteria: how reversible the action is, who is accountable for it, how long the process can wait and what the audit trail must show.

All of it is built on the same engines as the open-source edition. As we see it, that makes a process modeled on the open source a starting point for the platform, not a prototype to throw away.

Flowable vs Camunda, Bizagi, jBPM and Activiti on AI agents

Camunda, Bizagi, jBPM and Activiti also run BPMN processes. Camunda sells a process automation platform whose current engine is Camunda 8; Bizagi is a low-code automation platform; jBPM and Activiti are open-source engines, and Flowable began in 2016 as a copy of Activiti's code. What separates them in 2026 is where the AI agents live and the terms for running the engine in production. What we found in each vendor's or project's own pages, October 2026:

Camunda is the closest comparison on agents: both vendors model an agent as a step in a BPMN diagram and support MCP and A2A. The difference is underneath. Camunda's agents run on Camunda 8, whose engine runs as a separate service and whose production use on the company's own infrastructure requires Camunda's Enterprise license since version 8.6. Flowable's agents run in its commercial platform, which is built on engines that stay Apache 2.0 and can live inside a Java application, and Flowable keeps a CMMN engine for cases.

Bizagi, is a low-code platform: its Modeler supports BPMN 2.0, and its runtime runs a subset of the BPMN elements on Bizagi's platform, where its agents also run. The choice between Bizagi and Flowable is a managed low-code platform against open-source engines that a team can run, extend and embed itself, with the agentic platform as an option on top.

Aplyca support for the open-source engines in production

Running the open-source engines does not mean running them without support. Because the engines are published under Apache 2.0 with their full source code, a defect in the engine is not a black box: it can be reproduced, fixed in a patched build and reported to Flowable afterwards, without waiting for Flowable's next release to restore the service. Flowable also sells professional support subscriptions, which do not require an Enterprise license and are priced on request.

As a Flowable partner, Aplyca supports the open-source engines for its clients as a single point of contact, with the same service levels whatever the cause of a failure:

At level 4, the partner channel gives Aplyca a direct line to Flowable, together with Flowable's community. Clients who want Flowable's own contractual service level add its support subscription, either contracted by Aplyca and provided as part of its service, as Aplyca recommends, or contracted directly with Flowable, with Aplyca coordinating. In every case, Aplyca runs a pinned, stable version of the engine and plans each upgrade, runs a regression suite of the client's processes before changing the engine version, and can roll a version back without losing the state of running processes, because that state lives in a documented database schema and the definitions are BPMN 2.0 and DMN models. When a defect has no patch yet, the workaround can go in the integration layer or the portals without touching the engine. Aplyca commits to restoring the service within the agreed severity times, by its own patch or a workaround, without waiting for Flowable's next release.

When to stay on the open source, use the platform or choose another engine

The open-source engines fit when:

• The team works in Java, or through the REST API, and wants the engine inside its own application or infrastructure.

• The processes mix people and systems and must survive restarts, and the AI steps are few and well defined.

• The team is ready to build and run its own checks and monitoring around calls to AI models.

Flowable's commercial products fit when:

• Many steps call agents, and the organization wants guardrails, evaluators and cost tracking without building them.

• Business users model processes in a low-code tool, and operators need dashboards for cases and agents.

• Agents need to reach other systems through MCP or agents on other platforms through A2A.

Another engine fits when its own terms are the deciding ones: Camunda 8 for a team that wants Camunda's agents and runs the engine as a separate service under Camunda's license or in its cloud, and Bizagi for an organization that wants a managed low-code platform rather than engines to run itself. A process engine is not needed at all for a single automated task with no people and no waiting.

For organizations on Camunda 7 or Activiti, Flowable documents a migration path with a tool that checks existing process diagrams and, for some products, can carry history and running instances. That matters most for Camunda 7 Community installations, which no longer receive security patches.

Frequently asked questions

Is Flowable open source?

Its engines are: the BPMN, CMMN and DMN engines and the event registry are open source under the Apache 2.0 license. Flowable Work, Design, Hub and the Agentic Case Platform are commercial products built on them.

What is the difference between Flowable open source and enterprise?

The open-source edition is the engines and their Java and REST APIs, which a team embeds or deploys and operates itself. The enterprise products add the applications for users and modelers, operations tooling and the AI agent features, on a separate release line.

Who supports the open-source Flowable engines in production?

Flowable sells professional support subscriptions that do not require an Enterprise license. Aplyca, a Flowable partner, also supports the engines: it works on the engine's source code to restore the service within agreed times, and escalates to Flowable through its partner channel or a Flowable support subscription.

Are Flowable's AI agents open source?

They come with the commercial Agentic Case Platform, which includes the agent engine, the AI Agent Task, guardrails, evaluators and the MCP servers. The engines they run on are open source under Apache 2.0, and a team on the open-source engines can call AI models from its processes with standard steps.

Can a team use AI with the open-source Flowable engines?

Yes. A process can call an AI model's API through an HTTP task or hand the call to an external worker, and a user task can hold the AI model's output for a person to review. The team designs the checks and the monitoring to fit its needs, or adopts the platform's when it wants them ready to use.

How do Flowable's agents compare with Camunda's?

Both model an agent as a step in a BPMN diagram and support MCP and A2A. Camunda's run on Camunda 8, a separate engine service with a paid license for production on the company's own infrastructure; Flowable's run in a commercial platform built on engines that remain Apache 2.0 and embeddable.

A team that starts on the open source is building toward the platform

The decision for most teams is not which BPMN engine to use but where to start: on the open-source engines, building the first AI steps themselves, or on the platform, with agents, guardrails and cost tracking ready from the first process. Either way, the processes and their state live in the same engines, so, as we see it, a team that starts on the open source is building toward the platform, not away from it. For 20 years, Aplyca has built digital platforms for organizations such as the Cámara de Comercio de Bogotá, Grupo Energía Bogotá, Terpel, Vanti and Cine Colombia, whose transactional platform connects scheduling, seating, payments and invoicing. As a Flowable partner, Aplyca offers architecture consulting, implementation, migration from Camunda 7 or Activiti, AI agent integration, and support for the open-source engines.

See how Aplyca implements Flowable