Skip to main content

Flowable 2026.1.x Release Notes

Initial release 2026.1.0, July 16, 2026

Introduction​

The Flowable product comprises:

  • Flowable Agentic Case Platform, a platform that provides flexibility in AI LLMs and autonomy levels of using AI in a case context.
  • Flowable Case Platform, a process and case management platform with an out-of-the-box user interface..
  • Flowable Design, a modeling environment to create BPMN, CMMN, DMN, Form and other model types that run in Platform/Work/Engage.
  • Flowable Hub, an administration tool that can be used to manage the Flowable Platform.
  • Flowable Control, an administration tool that can be used to manage the Flowable Platform environments.
  • Flowable Inspect, a debugging and test component that can be used with Flowable Work and Engage.

These products are built on top of the Flowable Open Source project which can be found at Github.

Documentation​

The Flowable Open Source project also has extensive documentation available which can be found at https://www.flowable.com/open-source/docs/oss-introduction.

Highlights​

Flowable Agentic Case Platform​

  • A new guardrailing feature has been added to be able to define rules and verifications of an agent request or response.

  • Added MCP support to be able to interact with the platform from an agentic application. There is support to for example start case or process instances, or get the current state of a process, or complete a task etc.

  • In the attachment form component a new option has been added to do document analysis when uploading the document. A document agent can be configured for it to do classification for a content model type and to extract metadata information. The extracted metadata can be used to fill a configured set of form fields, all with approval of the knowledge worker / user of the form.

  • When an email is received via the email inbound channel, the email content and its attachments can be automatically classified with a document agent, to define the content model type. The email content and each attachment are classified separately.

  • Added a new evaluator feature that can be defined on utility, external and a2a agents. Evaluators are ran asynchronously on the response of an agent call and can be used to review and evaluate the response values against expected values and a range of values.

  • The dashboard builder has been extended with agentic dashboard components to show number of agent executions, token information etc.

  • Added support for the OpenAI Responses API, including Codex models, and integrated built-in tools like web and file search.

  • Added support for using Data Dictionary and Data Objects as JSON input and output for agent models.

Flowable Case Platform​

  • WCAG 2.2 AA compliance has been tested and audited and an audit report is available via your CSM or account manager.

  • Added support for document / content item events in Case and process models. A document event listener can be configured to listen to specific actions on documents in a specific folder, like creating a new document, update an existing document, setting a content model on a document, updating the metadata of a document etc. The document event information can be used to define case and process model logic, like starting a review and approve process when a new document is created.

  • Added improved support for email inbound channels to store the email and attachment information as content items, so that they are automatically attached to a case or process instances and the email content and attachments can be used in the case model and process model logic.

  • Added out-of-the-box support for File, (S)FTP, SQL and Azure Service Bus channel types. This can be extended with additional Camel connector support because the Design side is extensible.

  • Introduce CMMN error handling, similar to the already existing BPMN error handling. This is for example used by the new guardrailing feature in the agentic case platform, when a business error is thrown when a guardrail is matched.

  • When a service registry model mock is defined, the logic will use the defined mock response as the output of the service registry call.

  • Added support for multipart/form-data for service registry calls to allow to use content items as input for a REST call.

  • A new expression has been added for content items with ${contentItem.metadata.myKey} and ${contentItem.definition.key} support. You can now easily access the metadata of a content item and the content model definition information.

  • Introduced a housekeeping option for provisional content items that are not attached to a case, process, task or other scope. These are mainly content items that were uploaded in a form, but not completed as part of the scope. This can be enabled with the flowable.content.provisional.enable-cleaning application property.

  • Improved case migration support to allow for task properties like form key, due date and candidate groups to be updated in the migration.

  • Improved the reindexing functionality to use the batch feature and jobs to perform the reindexing.

  • Added support for using Data Dictionary and Data Objects as JSON input and output for services models.

  • Added expression support for variable extractors. Note that this has a potential performance impact and should be carefully evaluated.

  • Added support to use app and tenant variables in different start event type expressions, like start timer event expressions, start signal and message event expressions etc.

  • Implemented performance improvements to update large sets of master data.

  • Added support for x-api-key and custom header authorization in the REST service registry.

  • Added scripting helper flw.error.throwBusinessError(errorCode, message) to allow scripts to throw a cross-engine business error that is caught by both BPMN error boundary events and CMMN fault sentries with a matching code. flw.bpmn.throwError remains available for BPMN-only scripts.

  • Breaking change: A BusinessError that propagates to the REST layer (i.e. is not caught by a boundary event or fault sentry in the process or case definition) is now mapped to HTTP 400 Bad Request instead of HTTP 500 Internal Server Error. The response body contains message, exception and errorCode fields. Integrations that currently rely on a 500 status for uncaught business errors will need to be updated to handle 400.

  • Identity links are now stored for Instance, Task, and Activity levels, ensuring visibility in ElasticSearch queries for non-admin users.

  • Updated all date and time information in the platform UI to use an absolute date / time value, adhering to the defined date format.

  • Added support for internationalized values for audit task messages.

  • Added support for adding and editing data tables in a Rich text and display HTML form component.

  • Added support for action, REST, service, agent and script buttons on a data object edit form.

  • Improved support for deep links to a Flowable UI url where an OAuth login is shown. Now the UI should navigate to the deep link url after the OAuth login flow has been completed.

  • Added a new date range form component.

  • Updated to Jackson 3 for JSON handling. Note that this can be a breaking change and check the Flowable Case Platform upgrade notes for more details.

Flowable Design AI​

  • Improved the AI app generation with a guided, stepped approach that goes from validating the prompt for unclear parts that need more input, to proposing a basic case or process model structure, checking for REST and agent integrations and generating any needed integrations, proposing a data structure with data dictionary objects, to generating forms, generating case or process model. Then a validation step is performed to check the generated models, and check expression correctness. The final step is to generate test models and run them via Inspect. At the end of the AI app generation, a model overview is provided and the app and its models can be imported.

  • Added MCP support to be able to interact with the Design application from an agentic application. There is support to for example create case or process models, or other model types, or update an existing model with new functionality etc.

  • Added support for using remote MCP in the service registry model. See MCP Configuration Examples for more details.

  • A new mock functionality for an agent model has been added. The output based on a specific prompt can be defined and used when executing the agent as part of a case or process model.

  • Added support for testing document agents, where a document file can be provided and the output of the LLM call can be verified.

  • In Chrome browsers the translations can now be generated with AI in a property view where translations can be entered.

  • Added AI support to generate prompts in an agent model.

  • Support in agent models to use OpenAI compatible LLM providers with authentication support for basic auth, bearer auth, API keys and authentication with custom headers.

Flowable Design​

  • Added a new test model feature for Case, Process, Service and Agent models. You can define test models that can be executed from Design and deployed to Inspect to validate the model in different variations. For Case and Process models you can define an order in which you expect the test run to be executed with variable value validation and expression validations. You can also fill-in form data to make the testing experience even better. For the service and agent models the responses can be validated with all kind of different inputs.

  • A new approval workflow has been introduced when deploying apps to a platform environment. This can be enabled on a workspace and app level, and permissions can be granted to a user or group who should be able to approve a deployment request. An approver can see all outstanding and historic deployment requests and can verify if the app should be deployed or not.

  • A new app revision view has been added that shows a full view on the app details and its models of the chosen revision. You can open each model that's part of an app revision in a readonly way.

  • There is a new app revision diff view, that shows the changes between an app revision and another revision or current app state. At first it shows the models that are added, removed and updated. For each model that is updated, the changes are listed and a visual diff view is shown between the revision model and the other model state.

  • Support for Git connectivity has been added on an app level. First you can define the list of Git providers that you are using withing your company. This can be any Github, Bitbucket or Gitlab repo. Then you can clone an app from a Git repostory or connect an existing app to a Git repository. The integeration works with an exploded app stored in a Git repo folder or the root of the repository. Changes from the remote repository can be pulled and local changes can be committed. When a file is changed both in the remote repository and local repository then a visual conflict resolution is provided to get this resolved. There is also a diff view between different commits of a specific model.

  • It is now possible to define mock functionality for a service registry model. When the actual REST service is not available in a development or testing environment or you want to mock error or other specific responses, mocks can be used to test the model with such a response from the service registry.

  • Added support to define permissions for roles to restrict the functionality of Design for users. There are permissions for example to allow create workspaces and apps, create and edit models etc.

  • Permissions can now also be defined on app level, and not only on workspace level.

  • Added support for case and process models for plugin tasks. In this way a sub process instance can be started with the configuration of the process plugin task. And in the same way a sub process instance can be started as well.

  • Added support to define input and output parameters for a case and process model. When it's then used as a sub case or sub process the defined input and output parameters can be mapped in the interface parameter property view.

  • Added a new ERD diagram view to the data dictionary editor, to have a visual view on the entities, its entity relationships and properties.

  • A new variable view has been added to the Case and Process models by showing an overlay with the variables read and written by each step in the model. In addition also the data contract variables and parent and root variables are shown as well. The variable view can be enabled with a toolbar button.

  • Added testing support for action models, to make it easy to test the action logic without having to first deploy a page or form using the action to the platform.

  • Added support for defining custom validation error messages for data dictionary constraints on objects and properties.

  • Start forms of a case or process model can now be configured for the action form when the action type is starting a case or process instance.

  • Added support for HTML and templates for an email action in a SLA model.

  • Custom palettes can be exported and imported.

  • In the uses and used by view for a service model the operation level is included instead of only the general model level.

  • The deployment id of the app deployment to the platform is stored on the deployment approval request, so that a full audit is available which Design version was deployed to which environment.

  • Added support for custom composite form components, like the out-of-the-box Panel form component.

  • The category and message values for an audit task now have dedicated properties to make it easier to configure an audit task.

Flowable Inspect​

  • Added support for exporting and importing test models.

  • Added an agent instance view to see the agent interaction in a case or process instance. This also includes the agent timeline to see a full overview of all the agent and LLM interactions for an agent instance.

Flowable Hub​

  • This is the first version of Flowable Hub, which is the successor of the Flowable Control application. In the 2026.1.x release we still have both Flowable Hub and Control included, but starting with the 2026.2.x version on Flowable Hub will be included. The functionality that Flowable Hub provides should be on par with Flowable Control. The focus is on apps, definitions and instances instead of the engine focus of Flowable Control.

  • Added a new assisted case and process migration option for case and process definitions and single case and process instances. An analysis is done on all running instances of a definition, or on the single instance and then a migration action proposal is made to migrate the instance. It's also possible to filter the instances of a definition, to not have to migrate all instances at once.

  • A new dashboard has been added to provide more insight and guidance in the execution of jobs in the platform. Because jobs run in the background it's not always clear what is exactly happening and if for example the thread pool size is configured correctly. The dashboard provides an overview of the state of the job execution and provides guidance when there are slow running jobs that should be verified, or the number of job executors should be increased to cope with the amount of jobs etc.

  • A new dashboard has been added to show information about the evaluator execution of all agents in general and specific agents in more detail. Like the percentage of response that are within the expected results

  • A new agent dashboard has been added that shows invocation totals, token count, guardrailing violations etc.

  • A data object reference variable can now be updated to another data object instance.

  • Added owner and assignee information in the case and process instance view.

  • Add support to manage identity links in the case and process instance view.

Flowable Control​

  • A new dashboard has been added to provide more insight and guidance in the execution of jobs in the platform. Because jobs run in the background it's not always clear what is exactly happening and if for example the thread pool size is configured correctly. The dashboard provides an overview of the state of the job execution and provides guidance when there are slow running jobs that should be verified, or the number of job executors should be increased to cope with the amount of jobs etc.

  • A new agent dashboard has been added that shows invocation totals, token count, guardrailing violations etc.

  • A data object reference variable can now be updated to another data object instance.

  • Added owner and assignee information in the case and process instance view.

  • Add support to manage identity links in the case and process instance view.

Spring Boot​

  • Flowable has been upgraded to Spring Boot 4.1

Upgrade information​

  • Flowable requires a Jakarta EE version 11+ compliant web container, due to the upgrade to Spring Boot 4. For Tomcat this means at minimum Tomcat version 11.

Flowable Case Platform Upgrade Information​

  • Important: If you have scripts or expressions that call methods on a JsonNode, you need to carefully check if these work with Jackson 3, as many method signatures have changed (see details below). If you are unsure, we recommend starting with Jackson 2 configured first (flowable.variable-json-mapper=jackson2), and then testing for an upgrade to Jackson 3 over time. We do recommend looking into upgrading to Jackson 3, since Jackson 2 will eventually stop receiving updates. See Jackson Releases for the latest support information. Jackson 3 is used for Flowable internal json manipulation. There is still support for Jackson 2 variables. With Spring Boot this can be enabled by setting flowable.variable-json-mapper to jackson2. By default, Jackson 3 is being used for variables. When configuring Flowable without Spring Boot then the variableJsonMapper on the process, cmmn, and app engine configurations should be set to be org.flowable.common.engine.impl.json.jackson2.Jackson2VariableJsonMapper and the org.flowable.common.rest.variable.Jackson2JsonObjectRestVariableConverter should be added to the appropriate rest response factories. Notable changes when using JSON in expressions / scripts:

    • Packages have changed from com.fasterxml.jackson.databind and com.fasterxml.jackson.core to tools.jackson.databind and tools.jackson.core
    • elements() no longer returns Iterator of type JsonNode and instead returns Collection of type JsonNode
    • values() no longer returns Iterator of type JsonNode and instead returns Collection of type JsonNode
    • fieldNames() replaced by propertyNames()
    • fields() replaced by properties()
    • JsonNode with(String) replaced by ObjectNode withObject(String), and if not using a pointer then it is better to use ObjectNode withProperty(String)
    • TextNode textNode(String) replaced by StringNode stringNode(String)
    • findValuesAsText(String) replaced by findValuesAsString(String)
    • findValuesAsText(String, List) replaced by findValuesAsString(String, List)
    • boolean isContainerNode() replaced by boolean isContainer()
    • boolean isEmpty(SerializerProvider) replaced by boolean isEmpty(SerializationContext)
    • JsonNode put(String, JsonNode) replaced by JsonNode replace(String, JsonNode)
    • JsonNode putAll() replaced by JsonNode setAll()
    • JsonNode putAll(ObjectNode) replaced by JsonNode setAll(ObjectNode)
    • JsonParser traverse() removed without replacement
    • JsonParser traverse(ObjectCodec) replaced by JsonParser traverse(ObjectReadContext)
    • void serialize(JsonGenerator, SerializerProvider) replaced by void serialize(JsonGenerator, SerializationContext)
    • void serializeWithType(JsonGenerator, SerializerProvider, TypeSerializer) replaced by void serializeWithType(JsonGenerator, SerializationContext, TypeSerializer)

  • Methods deprecated in Jackson 3:

    • String asText() replaced by String asString()
    • String asText(String) replaced by String asString(String)
    • boolean isTextual() replaced by boolean isString()
    • String textValue() replaced by String stringValue()

  • There is also a behaviour change in the different xxxValue and asXXX methods. In Jackson 3 those methods would fail if the node is not of the appropriate type and / or if it cannot coerce the value to the requested type. e.g.

    • When using stringValue on a non StringNode or NullNode it would fail, in Jackson 2 it would return null.
    • When using asString on a ObjectNode or ArrayNode it would fail, in Jackson 2 it would return an empty string.

Design Upgrade information​

Pentest report​

  • A new pentest has been performed on Flowable Work and Flowable Design and the results are available via your Flowable account manager or contact person.

Flowable Agentic Case Platform Database changes​

  • Added columns NAME_ and CALLBACK_SCOPE_ID_ to the FLW_AGENT_INSTANCE table.

Flowable Case Platform Database Changes​

Design Database changes​

Hub Database changes​

Control Database changes​

Open Source Artifacts Dependency Compatibility​

Releases of Flowable Design, Work and Engage use versions of the open source Flowable dependencies that have not yet been published publicly on the Maven Central repository. These 'bugfix releases' can be retrieved by customers using the customer Flowable Maven repository credentials.

These versions contain fixes and have been QA'ed with the 2026.1.0 release. It's advised to upgrade your open source dependencies to the 'compatible' version mentioned below (and mentioned in the subsequent Service Packs section)

Open source dependency version: 8.1.0.21

Service Packs​