Update: The alpha release is officially live for all who wish to download.

Below is a summary of everything new in Camunda for this June with the 8.8-alpha5 release.

This blog is organized using the following product house, with E2E Process Orchestration at the foundation and our product components represented by the building bricks. This organization allows us to organize the components to highlight how we believe Camunda builds the best infrastructure for your processes, with a strong foundation of orchestration and AI thoughtfully infused throughout.

E2E Process Orchestration

This section will update you on the components that make up Camunda’s foundation, including the underlying engine, platform operations, security, and API.

Zeebe

The Zeebe team focused on big fixes for this release.

Operate

For this release, our Operate engineering team worked on bug fixes.

Tasklist

For this release, we have continued to work on bug fixes in Tasklist as well.

Web Modeler

With this alpha release of Web Modeler, we’re introducing powerful new features that streamline process modeling and enhance the developer experience.

Azure Repos Sync

Camunda now supports an integration with Azure DevOps, which allows for direct synchronization with Azure repositories.

FEEL Copilot

Pro- and low-code developers using Web Modeler SaaS can develop FEEL expressions with an integrated editor that pulls process variables and process context, making it easy for anyone to perform business logic in Camunda.

For Web Modeler SaaS customers, it also features the ‘FEEL Copilot’ which takes advantage of integrated generative AI to write and debug executable FEEL (Friendly Enough Expression Language) expressions.

Desktop Modeler

This alpha, we have also provided more functionality for our Desktop Modeler.

Process application deployment

A process application is now deployed as a single bundle of files. This allows using deployment binding for called processes, decisions, and linked forms.

Deployed decision link to Operate

After a DMN file is deployed to Camunda, links to the deployed decisions in Operate are displayed in the success notification.

Enhanced FEEL suggestions

Literal values like true or false are now displayed in the autocompletion for fast and easy expression writing.

Check out the full release notes for the latest Desktop Modeler 5.36 release right here.

Optimize

Our Optimize engineering team has been working on bug fixes this release cycle.

Identity

Camunda’s new Identity service delivers enhanced authentication and fine-grained authorization capabilities across both Self-Managed and SaaS environments. Key updates include:

• Self-Managed Identity Management: Administrators can natively manage users, groups, roles, and memberships via the Identity database—without relying on external systems.
  
• OIDC Integration: Supports seamless integration with standards-compliant external Identity Providers (IdPs), including Keycloak and Microsoft Entra (formerly Azure AD), enabling single sign-on (SSO) and federated identity management.
  
• Role-Based Access Control (RBAC): Provides resource-level access control with assignable roles and group-based permissions, enabling precise scoping of user capabilities across the platform.
  
• Flexible Mapping: Users, groups, and roles can now be dynamically mapped to resource authorizations and multi-tenant contexts, supporting complex enterprise and multi-tenant deployment scenarios.
  
• Migration Support: Simplified tooling facilitates migration from legacy Identity configurations to the new service, reducing operational overhead and enabling a phased rollout.
  
• Organizational Identity for SaaS: In SaaS deployments, customers can integrate their own IdP, allowing centralized management of organizational identities while maintaining cluster-specific resource isolation.
  
• Cluster-Specific Roles & Groups: SaaS environments now support tenant-isolated roles, groups, and authorizations per cluster, ensuring that customer-specific access policies are enforced at runtime.

Please see our release notes for more on the updates to Identity management.

Console

The Console engineering team has been working on bug fixes this release cycle.

Installation Options

This section gives updates on our installation options and various supported software components.

Self-Managed

For our self-managed customers, we have introduced a graceful shutdown for C8Run by rebuilding how we manage C8Run started processes. This resolves an issue where stopping C8Run during the startup process can create zombie processes.

We have also added features to support supplying image.digest in the values.yaml file instead of an image tag as well as the support for an Ingress external hostname.

Task Automation Components

In this section, you can find information related to the components that allow you to build and automate your processes including our modelers and connectors.

Connectors

We have introduced two connectors to support agentic AI with Camunda. You can find more on Camunda and Agentic in the Agentic Orchestration section in this blog post.

• The AI Agent connector which was recently published on Camunda Marketplace is now officially included as part of this alpha release and directly available in Web Modeler. This connector is designed for use with an ad-hoc sub-process in a feedback loop, providing automated user interaction and tool discovery/selection.
  
  The connector supports providing a custom OpenAI endpoint to be used in combination with custom providers and locally hosted models (such as Ollama).
  
• The Vector Database connector, also published to Camunda Marketplace, allows embedding, storing, and retrieving Large Language Model (LLM) embeddings. This enables building AI-based solutions for your organizations, such as context document search and long-term LLM memory and can be used in combination with the AI Agent connector for RAG (Retrieval-Augmented Generation) use cases.

Agentic Orchestration

With a continued focus on operationalizing AI, this section provides information about the continued support of agentic orchestration in our product components. This new Agentic Orchestration documentation section of our release blog is a great starting point to explore Camunda’s Agentic Orchestration approach. 

To support modern automation requirements, Camunda has adopted orchestration patterns that enable AI agents and processes to remain adaptive by combining deterministic with dynamic orchestration.

This architecture allows agents to incorporate dynamic knowledge into their planning loops and decision processes. The same mechanisms also support continuous learning, by updating and expanding the knowledge base based on runtime feedback.

To support this approach, Camunda has incorporated both our Vector Database connector and AI Agent Outbound connector directly into its orchestration layer.

Together, these capabilities allow Camunda to support agentic orchestration patterns such as:

• Planning loops that select and sequence tasks dynamically
• Use of short-term memory (process variables) and long-term memory (vector database retrievals)
• Integration of event-driven orchestration and multi-agent behaviors through nested ad-hoc subprocesses.

As mentioned in the Connectors section, we have recently released two connectors to support our approach:

• The AI Agent connector is designed for use with an ad-hoc sub-process in a feedback loop, providing automated user interaction and tool discovery/selection.
  
  This connector integrates with large language models (LLMs)—such as OpenAI or Anthropic—giving agents reasoning capabilities to select and execute ad-hoc sub-processes within a BPMN-modeled orchestration. Agents can evaluate the current process context, decide which tasks to run, and act autonomously—while maintaining full traceability and governance through the orchestration engine.
  
• The Vector Database connector which allows embedding, storing, and retrieving Large Language Model (LLM) embeddings. This enables building AI-based solutions for your organizations, such as context document search and long-term LLM memory and can be used in combination with the AI Agent connector for RAG (Retrieval-Augmented Generation) use cases.
  

If you would like to see these new connectors in action, we encourage you to review our website and see a video of how Camunda provides this functionality. We also have a step-by-step tutorial for using the AI Agent Connector in our blog.

Camunda 7

There are several updates in this release for Camunda 7.

Support for Spring Boot 3.5

This alpha release features support for Spring Boot 3.5.0.

New LegacyJobRetryBehaviorEnabled process engine flag

Starting with versions 7.22.5, 7.23.2 and 7.24.0, the process engine introduces a new configuration flag: legacyJobRetryBehaviorEnabled.

By default, when a job is created, its retry count is determined based on the camunda:failedJobRetryTimeCycle expression defined in the BPMN model.

However, setting legacyJobRetryBehaviorEnabled to true enables the legacy behavior, where the job is initially assigned a fixed number of retries (typically 3), regardless of the retry configuration.

In 7.22.5+ and in 7.23.2+ the default value is true for legacyJobRetryBehaviorEnabled. For 7.24.0+ the default value is false for legacyJobRetryBehaviorEnabled .

External task REST API and OpenAPI extended

Now the External task REST API is extended with the createTime field. OpenAPI is updated as well along with the extensionProperties for the LockedExternalTaskDto.

You can find the latest OpenAPI documentation here. Thank you for this community contribution.

Camunda 7 to Camunda 8 Migration Tools

With our Camunda 7 to Camunda 8 Migration Tools 0.1.0-alpha2 release, the Camunda 7 to Camunda 8 Data Migrator brings many quality of life improvements for our customers that are moving from Camunda 7 to Camunda 8.

Auto-deployment with Migrator Application

To help you migrate seamlessly, the BPMN diagrams that are placed in ./configuration/resources directory are auto-deployed to Camunda 8 when starting the migrator application.

Simplified Configuration

We’ve also made it easier to configure the Camunda 8 client allowing you to define client settings such as the Zeebe URL directly in the application.yml file.

Logging Levels

In addition, logging has been enhanced with the introduction of logging levels, as well as more specific warnings and errors.

For example, if a Camunda 7 process instance is in a state that cannot be consistently translated to Camunda 8, a warning is logged and the process instance is skipped.

To proceed, these instances must be adjusted in Camunda 7. Once complete, with the recent updates, you can resume migration for previously skipped and adjusted instances.

While the Camunda 7 to Camunda 8 Migration Tools are still in alpha, you can already check out the project and give it a try! Visit https://github.com/camunda/c7-data-migrator.

Thank you

We hope you enjoy our latest minor release updates! For more details, be sure to review the latest release notes as well. If you have any feedback or thoughts, please feel free to contact us or let us know on our forum.

If you don’t have an account, you can try out the latest version today with a free trial.

The post Camunda Alpha Release for June 2025 appeared first on Camunda.

Below is a summary of everything new in Camunda for this May 2025 8.8-alpha4 release.

This blog is organized using the following product house, with E2E Process Orchestration at the foundation and our product components represented by the building bricks. This organization allows us to organize the components to highlight how we believe Camunda builds the best infrastructure for your processes, with a strong foundation of orchestration and AI thoughtfully infused throughout.

E2E Process Orchestration

This section will update you on the components that make up Camunda’s foundation, including the underlying engine, platform operations, security, and API.

Zeebe

Zeebe engineers have been contributing to streamlining future functionality during this release cycle.

Operate

Our Operate engineering team has been working on bug fixes for this release cycle.

Tasklist

Tasklist engineers have been working on bug fixes for this release cycle..

Web Modeler

With this alpha release of Web Modeler, we have new features that improve change governance and help Self-Managed users deploy and test their processes.

Description field for versions

In addition to the version tag, there is a new dedicated description field on versions that serves as a change log or a Git commit message to track what changed and why.

In previous versions, the version name field was doing too much—sometimes used to indicate the actual version, and other times repurposed as a quick commit message or change summary. This led to confusion and limited clarity during reviews and collaboration.

Shared resources like connector templates now support a description field, allowing developers to document changes meaningfully. Whether you’re publishing to shared resources or consuming a template, you’ll have better context and insight into what’s new.

These enhancements are designed to make versioning more intuitive and collaborative—helping teams stay aligned and reducing ambiguity.

Username/password deployment (Self-Managed)

Web Modeler now supports HTTP Basic Authentication, unblocking teams that rely on username/password authentication to deploy to their Self-Managed environment.

This update makes the deployment experience more flexible and accessible, especially for teams with simpler or legacy authentication needs.

Scenarios support (Self-Managed)

Self-Managed users can now replay scenarios in Play. You can use Play to quickly repeat manual test suites by recording and playing back process instances as scenarios. As you save completed instances as scenarios, Play calculates the percent of elements covered by the scenario suite. This is the first iteration towards a low-code process testing solution in the Web Modeler.

Desktop Modeler

With this release we have provided support for the following features:

Support for upcoming Camunda features

Camunda 7.24 is now supported with Desktop Modeler.

Application settings

You can now select your default execution platform version directly within the application. Configure selected application properties which were previously available only as flags.

Enhanced RPA integration

You can now use keyboard shortcuts to add comments, manage RPA scripts within process applications, and directly open “.rpa” files. If you’re on Windows or Linux you need to update the file associations for “.rpa”.

Check out the full release notes for the latest Desktop Modeler v5.35.0 release right here.

Optimize

Our Optimize engineering team has been working on bug fixes for this release cycle.

Identity

In this release cycle, our Identity engineering team has continued to add features around the management of tenants along with bug fixes.

Console

Our Console engineering team has been working on bug fixes for this release cycle.

Installation Options

This section gives updates on our installation options and various supported software components.

Self-Managed

Helm

The following features are available with Helm in this release:

• Improved the definition of Persistent Volume Claims (PVCs) by including the kind and apiVersion for configuration in the statefulset PVCs.
  

  

• Corrected one of the  sources of “option is a table” Helm warning with the Elasticsearch suboptions.
• Support for the global.extraManifests can now be used to add arbitrary Kubernetes data to the Helm chart.
• New guide to connect and use external PostgreSQL via Helm Charts.
• Diagnostics collection script automates the process of gathering logs and diagnostics from a Camunda Helm chart deployment running in a Kubernetes deployments to aid in troubleshooting.

C8Run

• The startup message of Camunda 8 Run (C8Run) now adjusts ports dynamically depending on whether C8Run runs with the --docker flag or not.
• The C8Run binaries for MacOS are now signed & notarized and no longer show the pop up “C8Run not opened”.
• C8Run is now available from the Camunda’s Download Center. 
• C8Run now provides a method for fetching JAVA_HOME and JAVA_VERSION automatically for Camunda support.

Task Automation Components

In this section, you can find information related to the components that allow you to build and automate your processes including our modelers and Connectors.

Connectors

We updated connector functionality and provided some new additional connectors with this release.

• We now offer a new Hubspot connector providing the following:
  • Efficiency: The new connector automates data transfer between HubSpot and Camunda eliminating manual entry and reducing errors.
  • Accuracy: This connector ensures data consistency across both platforms, providing reliable information for decision-making.
  • Productivity: Speed up workflows by automating contact, company, and deal updates between systems using the new Hubspot connector.
  • Integration: Seamlessly connect HubSpot and Camunda, enabling holistic process orchestration.

• Manage and Run: With this release, Camunda provides a consolidated view of all webhooks, message queue subscriptions, and polling subscriptions for efficient monitoring and management for multiple connector runtime instances.
• Secrets are now hidden from the error message in Operate enhancing both security and message clarity.
• We have improved OpenAPI handling with our element template generator.
• REST Connector: customers can now choose if they want to send null values (from the request body).
• Our Email connector now exposes what Message-ID provided in the response or improved traceability, easier correlation, and better integration with systems that may rely on the Message-ID.

We hope you enjoy everything in the latest Connectors updates in this release right here.

Artificial Intelligence

With a continued focus on AI, this section provides information about the continued support of AI in our product components.

With this release, we have created a preview of our AI Agent with a blueprint of an AI Email Support Agent available in Camunda Marketplace. This blueprint takes advantage of our new Embeddings Vector Database connector to provide support for storage and retrieval of vector embeddings to provide long-term memory to AI Agents.

We encourage you to check out this new functionality. Each blueprint comes with a README and files to help you get started.

The AI Agent and vector database connector will be available in a subsequent alpha release for version 8.8.

C7 to C8 Migration Tools

We started working on the C7 to C8 Data Migrator in April and we are excited to present the very first version, 0.1.0-alpha1. This tool migrates running and completed process instances from Camunda 7 to Camunda 8. We are currently focusing on the runtime process instance migration.

Later this year, we will continue to productize the history process instance migration. The history process instance migration will initially be limited to RDBMS setups. The Data Migrator is a Spring Boot-based standalone application that connects to any C7 database and the C8 REST API.

It is important to ensure that your C7 process models are migrated and deployed to C8 before you continue migrating data. We are still in the early stages, and much work is ahead before the Data Migrator reaches general availability. Nevertheless, you can already check out the source code repository and play around with it—we are interested in your feedback!

Thank you

We hope you enjoy our latest alpha release updates! For more details, be sure to review the latest release notes as well. If you have any feedback or thoughts, please feel free to contact us or let us know on our forum.

If you don’t have an account, you can try out the latest version today with a free trial.

The post Camunda Alpha Release for May 2025 appeared first on Camunda.

These changes focus on simplifying the API experience and streamlining API interactions to align with our customer’s evolving needs. We understand that API updates can sometimes be daunting, but we are committed to supporting you every step of the way.

Below, we outline what’s changing and how we’ll assist you in transitioning smoothly.

Why these changes to the Camunda API?

As part of this ongoing initiative, we aim to provide a unified experience with a single REST API for the orchestration cluster to simplify installation, onboarding, and accelerate the development process. By migrating and harmonizing endpoints in the Camunda 8 REST API, we make it easier to access resources with a consistent experience while ensuring all endpoints are secure with authentication and fine-grained resource authorization. 

The Camunda 8 REST API will offer parity to endpoints that were previously available in the component APIs (Zeebe, Operate, Tasklist, Identity, Optimize), actuator endpoints (usage metrics, backups, cluster scaling, etc.), and expand beyond with the new capabilities. This will be a single API to manage the orchestration cluster.

 Administration and Web Modeler APIs will not be part of the Camunda 8 REST API, as these are platform APIs outside the cluster’s scope. 

What’s changing ?

Camunda 8.6 (live today)

Introduction of the Camunda 8 REST API

With the most recent 8.6 release, customers can already use the first part of the Camunda 8 REST API to manage process entities (processes, decisions, user tasks, forms). For easier installation and configuration, all the functionalities (except Job Push) that were previously available in Zeebe gRPC API are now available as REST endpoints.

The Camunda 8 REST API will be the default API going forward for new functionalities that we’re building in the API, and new process management endpoints (e.g., Message Correlation with Result) will only be available with this API.

The process management endpoints in Camunda 8 REST API are already available in all officially supported API Clients—Zeebe Java Client, Spring Zeebe SDK, and JavaScript SDK. 

Camunda 8.8 (planned for October 2025)

Camunda 8 REST API for querying and permission management

We will release query endpoints for process entities (processes, decisions, user tasks, and forms) that will replace component APIs (Tasklist, Operate) going forward. We will also include endpoints to manage and query users and resource permissions in an orchestration cluster. All the Camunda 8 REST API endpoints will support resource-based authorizations to enable fine-grained permissions.

As part of this initiative, we’re aligning our API terminology so that the same technical asset has an identical, easy-to-understand, descriptive property name. This will simplify interactions and make the naming conventions clearer and more explicit.

Advanced search for Query API

We will provide a flexible API for building advanced, fine-grained filters to enhance the API experience and ease the implementation of advanced use cases. This will enable our customers to efficiently search and filter Camunda entities using logical and comparison operators. The first endpoints supporting this capability will be process instance search and user task search. Subsequently, we will expand this functionality to other search endpoints.

Updated Camunda SDKs

Starting with 8.8, the Zeebe Java client and Spring SDK will become the new Camunda clients. This change introduces a refreshed client structure designed to enhance the developer experience, introduce new features, and maintain compatibility with current codebases.

The Camunda Java client and Spring SDK are built directly on the Zeebe client infrastructure (Zeebe Java Client and Zeebe Spring SDK), which may already be familiar to you. This new release reflects our ongoing commitment to a unified API experience by renaming and expanding prior Zeebe clients to integrate with the Camunda API easily.

With the 8.8 release, Zeebe clients (Java and Spring) will be deprecated but can still be used as before. These clients will be removed with the 8.10 release, which is in line with API removal.

Swagger UI and Postman collection

For local development, it’s essential to quickly test the platform via API to manage and query processes. To make this easier, Swagger UI will be available for Camunda 8 REST API in SaaS and Self-Managed installations. A Camunda-supported Postman collection for Camunda 8 REST API provides an easy way to discover, test, and integrate APIs.

Camunda Process Test

We will release the Camunda Process Test for Java and Spring projects, enabling developers to test their processes comprehensively using Camunda 8 API endpoints. With features like different types of assertions, test isolation, and mocking BPMN elements, developers can now confidently test their processes within their preferred environments.

Deprecation of the Operate API and Tasklist API

We will begin the deprecation process for the Operate and Tasklist REST API. These APIs will still be available with Camunda 8.8 and 8.9 but won’t be recommended for new implementations. Starting in Camunda 8.10, these APIs will be removed entirely.

With the 8.8 release, customers can begin migrating to the Camunda 8 REST API for querying to prepare for this change and solve the same use cases.

Removal of the Tasklist GraphQL API

The Tasklist GraphQL API will be removed from the product at the conclusion of the deprecation process of Tasklist GraphQL API. Customers who haven’t had a chance yet to migrate can use Camunda 8 REST API for User Task interactions (both management and querying).

Deprecation of Job-based User Tasks querying and management

User tasks can be implemented with two different task types: the Job-worker and Camunda User Task (formerly known as Zeebe User Task). The differences in the implementation are as follows:

• The Job-worker type is a job with a list of custom headers visible in the query API. This type of user task is managed in Tasklist, and changes made before completing a user task are not replicated to another region (in case of multi-region deployment) or exported on the log stream (not available to custom exporters). This user task type is supported only with Tasklist REST API. 

• The Camunda User Task is an engine-native concept where Zeebe manages the state of the user task. This means that data replication and resilience are fully supported, and any changes to user tasks are available to custom exporters. Additionally, with the 8.8 release, customers can react to task lifecycle state changes with task listeners. This user task type is supported with Camunda 8 REST API for management and querying, and Tasklist API for querying. 

To streamline the development of process applications, we recommend using Camunda User Tasks in your process definitions. Starting with 8.8, Camunda modelers will automatically apply the Camunda User Task type and display a warning message for each Job-worker user task.

The Job-worker user tasks will be available for querying until the 8.10 release. With 8.10 and later, customers can use the Job-worker implementation of user tasks as standard jobs with headers to enable open architecture and composable solutions.

Deprecation of Zeebe gRPC API endpoints not necessary for performance use cases

We recognize and value the advantages that gRPC brings to the product. However, it’s challenging for some customers due to network requirements and gRPC is not as popular as other protocols. 

With this release, several Zeebe gRPC endpoints will be deprecated. Key gRPC endpoints necessary for high-throughput and low-latency applications will remain available to ensure peak performance for specific use cases. Based on benchmark comparisons between REST and gRPC, the final list of retained gRPC endpoints will be confirmed with the 8.8 release. Selected endpoints will remain active, with the others scheduled for removal in the 8.10 release.

Deprecation of Zeebe Process Test

Until now, Camunda 8 users have relied on the Zeebe Process Test (ZPT) library to unit test BPMN processes. ZPT served us well, leveraging an in-memory Zeebe engine with gRPC to run tests and verify process behavior.

However, as our platform evolved, ZPT could no longer fully support the latest Camunda 8 features, including our new REST API and user task functionalities. Additionally, as part of our API streamlining strategy, most of our gRPC endpoints will be phased out by version 8.10, making ZPT incompatible moving forward.

To address these challenges and provide our customers with enhanced testing capabilities, we’ve developed a completely new testing library: Camunda Process Test (CPT). Find out more about ZPT and CPT here.

Camunda 8.9 (planned for April 2026)

Camunda CLI: the CLI client for Camunda 8 API

We’re excited to introduce a new command-line interface for interacting with Camunda REST API directly from the terminal. Camunda CLI is the successor to zbctl, offering a more streamlined and unified way to interact with Camunda. Whether evaluating Camunda or quickly testing process execution, Camunda CLI makes it easy—it supports core process management and querying endpoints.

Just authenticate to the cluster and create a process instance, query user tasks or instances, create workers, and much more—all from your terminal.

Harmonization and unification of the system API

To simplify platform operations, we will harmonize the system API within the Camunda 8 REST API, ensuring all endpoints are secured and supporting resource authorizations. Endpoints like Prometheus metrics, usage metrics, backups and others will be unified and provided for the entire orchestration cluster, not just per component anymore.

By harmonize, we mean there is a single endpoint to trigger specific platform operations for the entire cluster (e.g., backup) in the /system API path and unified, as the terminology will be the same for different technical components (e.g., Prometheus metrics).

Camunda JS SDK for the browser

With Camunda 8.9, we will release a new version of the Camunda JS SDK that runs both server-side via Node.js and natively in the web browser. This unlocks greater architectural flexibility for your applications. The Camunda JS SDK will support the full Camunda 8 REST API.

Camunda 8.10 (planned for October 2026)

Zeebe gRPC API and Zeebe REST API removed

With this release, previously deprecated Zeebe gRPC API endpoints will be removed. We will keep endpoints meant for high-throughput and low-latency use cases.

Since the Camunda 8 REST API includes all the same endpoints for process management as the Zeebe REST API since the 8.6 release, we will remove the Zeebe REST API to make it easier to identify the proper API for process management.

In line with Camunda 8’s shift to a REST-first approach, the Zeebe gRPC API will be disabled by default for new clusters in self-managed installations, allowing for REST-only communication. For those who need it, enabling gRPC will be straightforward via configuration settings.

Operate REST API and Tasklist REST API removed

To further streamline Camunda 8’s architecture and API experience, we will remove previously deprecated APIs—Operate and Tasklist. Customers can migrate to the Camunda 8 REST API, which provides the same functionality and goes beyond to facilitate advanced use cases.

Removal of Job-based User Tasks querying and management

With the removal of the Tasklist REST API, job-based user tasks will no longer be supported for querying and task management. This type of user task will be handled as a standard job with custom headers, and the Job API can be used to manage these tasks. For customers who require task lifecycle support and task querying, we recommend using the Camunda User Task type.

Removal of Zeebe Process Test (ZPT)

After the deprecation period, the ZPT testing library will be removed in favor of Camunda Process Test (CPT), a new-generation testing library. CPT has been available since the 8.8 release.

Removal of Zeebe clients (Java and Spring)

Zeebe client classes and Zeebe clients (Java and Spring) will be removed in favor of Camunda clients, which have been available since the 8.8 release.

Real-time GET endpoints for user tasks and variables

This initiative will provide additional endpoints to retrieve the runtime state of process entities (user tasks, variables). These GET methods play a crucial role in enabling users to implement runtime interactions, where the current state of an entity is essential for deciding the next action. We’re still discovering use cases and requirements for this functionality, so if you have feedback about this, please add a comment here.

Key dates and actions

To help our customers stay on track with these changes, here’s a quick summary of important updates:

• Camunda 8.8: Start migration to Camunda 8 REST API for querying. Start migrating tests from the Zeebe Process Test to the Camunda Process Test.
• Camunda 8.9: Harmonized Monitoring API available.
• Camunda 8.10: Removal of Zeebe REST API, specified Zeebe gRPC endpoints, Operate API, Tasklist API, Zeebe Process Test, and Zeebe clients.

In relation to the roadmap, we intend to outline general plans with planned releases. This does not represent commitments, as deliverables are subject to a number of risks and uncertainties, many of which involve factors or circumstances beyond Camunda’s control.

Migration and support

We understand that these changes may raise questions about compatibility and migration. To ensure a seamless transition, we will provide comprehensive step-by-step migration guides, documentation for moving from V1 to V2 APIs, and instructions on using new clients to simplify interactions. The migration guides will also highlight the differences between both APIs.

These resources will also include detailed instructions on migrating from job-based user tasks to the Camunda user tasks to enable advanced Human Task Orchestration use cases.

As we prepare for these changes, we want to assure our customers that we are here to support them throughout the transition. Don’t hesitate to visit our forum as well to check how others are approaching migration and share your best practices.

What’s next?

We encourage all customers to begin reviewing the Camunda 8 REST API and reach out to us with any questions. Our product, engineering, and consulting teams are here to assist with any concerns or clarifications you may have.

We look forward to seeing how these changes will ease onboarding and installation while streamlining product operations.

Stay tuned for more updates on our blog and detailed documentation on step-by-step migration, which will be available together with the Camunda 8.8 release.

The post Upcoming API Changes in Camunda 8: A Unified and Streamlined Experience appeared first on Camunda.

• Balance compliance with adaptability in AI agents
• Build better AI agents leveraging BPMN standards
• Go from 0 to process diagram in seconds with Camunda Copilot
• Flexible and composable AI-powered document processing from Camunda
• Bridge the gap between legacy and modern technology with Camunda RPA
• See the “Agentic Orchestration for the Enterprise” webinar replay and learn more

AI is fueling a new era of innovation that is rapidly reshaping how businesses serve their customers and how they operate, compete and win.

AI’s early impact has been most notable in driving significant advancements in personal productivity. Its true potential, however, lies in its transformative ability to revolutionize how organizations engage with customers, innovate and deliver products, collaborate seamlessly with partners and suppliers, and empower their teams to achieve greater efficiency and impact.

The current reality is that many organizations are struggling to move beyond isolated AI use cases, leading to fragmented solutions delivering only marginal benefits. According to Camunda’s 2025 State of Process Orchestration and Automation Report, 84% of IT and business leaders are looking to add more AI capabilities over the next three years. However, that same report indicates that 85% of organizations say they are facing challenges in being able to scale and operationalize AI across their organization.

The key to unlocking AI’s full potential is going beyond isolated applications and operationalizing AI within a holistic, composable enterprise architecture—one that seamlessly integrates AI with people, systems, and devices. Process Orchestration and Automation (PO&A) is that essential, intelligent building block for this transformation; bridging the engagement layer—where customers and employees interact—with the core technology and data layer. Without this connection, experiences remain fragmented, limiting AI’s ability to enhance operations and deliver seamless, intelligent interactions.

We’re excited to announce the general availability of new agentic process orchestration capabilities to model, deploy and manage AI agents seamlessly into your end-to-end processes. We’re also debuting new AI-enabled capabilities, including agents powered by BPMN ad-hoc sub-processes, for dynamic, intelligent decision-making, as well as powerful new Camunda Copilot features for AI-powered process generation.

Balance compliance with adaptability in AI agents

Camunda’s process orchestration and automation enables organizations to operationalize AI with both flexibility and control by blending both deterministic and non-deterministic orchestration. This balance ensures compliance and standardization where needed while introducing AI-powered personalization, adaptability and resilience wherever it benefits them. Our highly scalable orchestration layer is designed to process real-time data and high transaction volumes, which is essential for delivering personalized customer experiences and proactive employee assistance.

Camunda’s composable architecture means you’re never locked into a single AI or automation technology. Our flexible, full-stack process orchestration platform enables end-to-end automation across people, systems, devices, and AI, driving efficiency, agility, and innovation at scale, and now, with the general availability of two new out-of-the-box capabilities, customers can further reduce automation sprawl and silos. Which is why we’re also excited to share more details around our new robotic process automation (RPA) solution and AI-powered intelligent document processing (IDP) solutions to help customers reduce the automation sprawl and silos they’ve created with task automation solutions backed by the best process orchestration and automation engine available!

Build better AI agents leveraging BPMN standards

Camunda’s new agentic process orchestration capability empowers organizations to model, deploy and manage AI agents seamlessly into your end-to-end processes. Combining deterministic (orchestration logic that’s defined at design time) and non-deterministic (orchestration logic is determined at runtime, leveraging AI models and runtime data) process execution ensures compliance and provides organizations control and transparency while leveraging AI-driven decision-making to enhance automation and optimize and scale business processes efficiently.

The introduction of ad-hoc sub-processes to Camunda (released in 8.7) allows tasks to be activated dynamically, removing requirements for modeling task sequence, task order or task completion; this is all handled in runtime by the ad-hoc sub-process logic. By utilizing BPMN ad-hoc sub-processes, AI agents can autonomously manage tasks within a defined scope, executing them in any order, repeating steps as needed, or skipping them entirely based on real-time conditions. With Camunda’s agentic process orchestration, companies achieve greater efficiency, transparency, and resilience in their operations, all while maintaining governance and alignment with business objectives. And, built-in support for ad-hoc sub-processes and AI connectors means organizations can confidently experiment and build AI into their processes with reduced risk.

Get started building AI agents and using agentic process orchestration with Camunda.

Go from 0 to process diagram in seconds with Camunda Copilot

We’ve added more exciting features to our Camunda Copilot to help you accelerate process modeling; enabling technical and business users alike to generate BPMN-compliant diagrams from natural language descriptions in minutes. Users can describe their process using the text-based UI in Camunda’s SaaS Web Modeler and quickly receive a BPMN diagram, complete with context and diffs to help them understand their new process. They can ask any follow up question, like how the process works, which test cases are recommended or what suggested performance KPIs might be, along with their expected values. They can also iterate on the process through chat to address more business requirements like designing to meet an SLA or ensuring certain steps occur.

The possibilities to save time, reduce manual effort and increase the quality in your process models with Camunda Copilot grow with each new use case we ideate. Two exciting use cases are to instantly create BPMN models from existing process documentation, or convert legacy code or proprietary non-BPMN models (XML, COBOL, BPEL, Java, etc) to BPMN standard models to aid in migration from other tools and platforms. We’re excited for customers to begin putting Camunda Copilot to the test and can’t wait to hear your feedback—especially about the new use cases you’re exploring!  

Comprehensive orchestration with composable task automation

Shifting from isolated applications to a holistic, composable enterprise architecture that integrates AI alongside people, systems, and devices will operationalize AI and drive intelligent automation across end-to-end business processes. This shift is critical for organizations to realize the full potential of AI. We’re excited to share more information about new built-in task automation capabilities; however, Camunda’s composable architecture means you can opt for best-of-breed, blended, or fully Camunda-powered end-to-end automation solution as part of our comprehensive, scalable orchestration layer.

Flexible and composable AI-powered document processing from Camunda

Leverage the power of large language models (LLM) to automate and simplify how complex documents are handled with Camunda’s seamlessly integrated Intelligent Document Processing (IDP) solution. With an intuitive, user-friendly interface, you can effortlessly configure, test, and optimize data extraction—all in one place.

With Camunda’s IDP solution, you can easily digitize non-machine-readable documents and convert them into structured data, making them accessible and actionable for AI-driven automation and decision-making. Benefit from seamless integration into your end-to-end process orchestration efforts and effortlessly extract and process information from any document type to gain valuable insights, identify trends, and streamline workflows—minimizing errors, saving time, and strengthening your competitive edge. Plus, with one-click deployment, you can quickly create reusable templates, accelerating implementation and scaling efficiency. What’s more, you have the flexibility to choose the right LLM model for your needs, customize and extend IDP capabilities as required, and leverage Camunda’s composable architecture to either use our IDP solution or integrate another best-of-breed capability.

See the IDP documentation to get started.

Bridge the gap between legacy and modern technology with Camunda RPA

Traditional RPA tools often create automation silos, making it difficult to scale and adapt as business needs and technology evolve. Camunda’s RPA solution takes a different approach, seamlessly integrating legacy systems into end-to-end process orchestration. By simulating APIs and decoupling business logic from integration logic, our RPA ensures that automation remains scalable, adaptable, and future-proof.

Through a curated subset of the RPA Framework library built on Robot Framework, our RPA solution ensures ongoing support for essential automation capabilities, so users can modernize and build bots confidently. By bridging legacy systems with AI through process orchestration, businesses can unlock valuable data that would otherwise remain trapped, allowing them to fully operationalize AI across all people, systems (even legacy), and devices. With a composable architecture that provides full visibility and control, Camunda RPA enables organizations to unlock efficiency, reduce complexity, and streamline manual tasks.

Check out our RPA getting started guide.

And so much more

Beyond the agentic process orchestration, AI-powered process orchestration and task automation features we’ve described above, we’ve also released so much more including Process Landscape Visualization,  Camunda 8 SaaS Editions Available on AWS and the Camunda SAP Integration, and many other exciting features. Read about them in the 8.7 release blog post.

Learn more from our team

Want to dig deeper into how we can help you jumpstart your journey to operationalizing AI? Or see these exciting features in action via demo?  Watch the replay of our “Camunda 8.7: Agentic Orchestration for the Enterprise” webinar and get insights and a closer look.

The post Camunda Releases Agentic Orchestration for the Enterprise appeared first on Camunda.

Release 8.7 brings new features around artificial intelligence (AI) investments into the product to improve the user experience and flexible, future-proof approach to process automation and AI adoption. Camunda enables you to overcome the limitations of fragmented automation and siloed AI so you can connect your automation efforts across people, systems and devices, unlocking lasting business value.

We accompany this investment in AI with the power of Intelligent Document Management (IDP), Robotic Process Automation (RPA), SAP Integration, Camunda Copilot and more. This post will delve into the power of agentic process orchestration, ad-hoc sub-processes and our newest features to provide you with our best enterprise-grade process orchestration and automation platform.

Below is a summary of everything new in Camunda 8.7.

Introduction to the new release blog

We introduced a new format for our release blog posts several months ago. As a reminder, this format organizes the blog using the following product house, with E2E Process Orchestration at the foundation and our product components represented by the building bricks. We have organized our components as per the image below to show how we believe Camunda builds the best infrastructure for your processes, with a strong foundation of orchestration and AI thoughtfully infused throughout.

E2E Process Orchestration

This section will update you on the components that make up Camunda’s foundation, including the underlying engine, platform operations, security, and API.

Zeebe

Support for ad-hoc sub-processes

The new Camunda version supports a new BPMN element: the ad-hoc sub-process. This new kind of sub-process allows more flexible process flows with a compact visual representation. It is the first step towards dynamic processes and execution of ad-hoc activities.

Support for deploying and linking Robotic Process Automation (RPA) scripts

In Camunda 8.7, Camunda proudly announces the 1.0 release of its integrated Robotic Process Automation (RPA) solution, now fully production-ready. This major update introduces a suite of powerful features designed to enhance the development, deployment, and management of RPA scripts.

Cancel banned instances

You can now cancel banned instances. A banned instance occurs when an unexpected, unhandled error happens in the Zeebe engine. When this happens, the process instance is frozen and will never terminate. To avoid causing confusion or taking unnecessary space, you can cancel it, effectively deleting it from the engine.

We hope you enjoy the latest Zeebe 8.7 release right here.

Operate

Support for ad-hoc sub-processes

Operate now supports a new BPMN symbol—ad-hoc sub-process. With this support, you can check what elements from an ad-hoc sub-process have been executed and which are in process, etc. This facilitates end-to-end visibility into process execution while enabling ad-hoc execution, depending on the specific case.

We hope you enjoy everything in the latest Operate 8.7 release.

Tasklist

Camunda’s Document Handling makes use of new components on Form-JS. These are:

• File Picker and

• Document Preview

File Picker

You can now choose to include a “file picker” to select a file or multiple files (as configured) to upload to your process instance.

When included on your form, you configure the form element.

When the form has been assigned in TaskList, you can select the Browse button to include the appropriate files.

When files have been successfully uploaded, the name of the file(s) will appear on the form.

Document Preview

Now, you can add a Document Preview to a form to preview documents associated with the process.

When a user is interacting with the form, they will see the document in preview, something like this.

In this release, we have also worked on bug fixes and minor improvements for Tasklist. We hope you enjoy all the latest updates!

Web Modeler

README support

Web Modeler now supports the README file type in common markdown format to formally document your process.

Users can create, edit, preview, version and diff README files within Web Modeler as with any other supported file type. In addition, your README files that are inside your process application can be synced with your Git repository.

Process landscape visualization

Web Modeler automatically generates an interactive visualization of all BPMN files within a project, folder or process application that shows connections between them allowing users to quickly understand the structure of a project and the process dependencies.

Users can view the process landscape and interact with this visualization. For example:

• You can click a node to view the details of the selected BPMN file including the latest version and the README.
• You can also search for a specific file.
• You can highlight the entire hierarchy of related connections.

Sharing projects for organization-wide collaboration

With the introduction of process landscapes and README support, users can leverage the existing capabilities within Web Modeler for organization-wide collaboration. You can create a shared project and invite collaborators—it’s now possible to invite all users in the organization at one time—to this shared project for organization-wide reuse.

Users can also view the landscape of the shared project to see details of specific versions including the README and then reuse them by copying these versions into their target project.

Bulk publish of connector templates to shared resources

It is now possible to use the public API to publish a connector template version to the organization.

Milestones are now versions

In previous releases, Camunda referred to versions of files as “milestones” for certain cases. We now refer to all of these as versions to avoid any possible confusion.

Process application versioning

With 8.7, we introduce the concept of a process application version and link the versions of the individual assets created to this process application version. As a result, when selecting a process application version, you now know which resources are present for this version and can also view its contents. We can also perform actions like restore a version, deploy, download, delete, rename, and copy.

Process application review

Web Modeler now offers form review support for process application versions. Users can request a review of a process application version and update those changes to production in an approved manner. Reviewers can view the changes made in the version and approve or request modifications. Organization administrators can enforce these reviews before manual deployment to production.

Mono-repository Git Sync

Web Modeler offers the path option when using Git Sync which provides enterprise organizations the flexibility to safely integrate Web Modeler without charging their repository structure. Administrators can synchronize process applications with a defined path so that they can sync multiple process applications to the same repository.

GitLab Synchronization

Web Modeler now supports native integration with both GitLab as well as GitHub. Previously, we only supported GitHub for synchronization. This ensures seamless synchronization between Web Modeler, Desktop Modeler, and official version control projects.

Simplified deployment experience

With 8.6, Caunda introduced configuring clusters in Web Modeler for an easier deployment experience from a list of pre-configured clusters for deployment. In 8.7, we have simplified the deployment experience even further. User tokens are now used to authorize deployment, so users no longer have to enter credentials for a specific cluster requiring authentication.

Connector template generator

Now it is possible to automatically generate a custom connector template directly from Web Modeler by importing an existing API definition, such as an OpenAPI specification, Swagger specification, or a Postman collection.

Support for non-public database schemas

Customers can now easily install Web Modeler using a non-public PostgreSQL database schema without any additional configuration steps.

Multi-tenancy support with Play

Play now supports multi-tenancy.

Appending tasks

You can now create and append tasks with available resources within the current project. You can find the available processes, decisions, and forms in the append menu to directly create a task linked to that resource.

Zeebe User Tasks

With this release, user task events have been renamed to “Camunda user tasks” and this is the default type in Modeler. Job worker-based user tasks have been depreciated, with migration support provided to help transition smoothly to the new implementation type.

BPMN Copilot (SaaS only)

Thanks to Camunda’s integrated BPMN Copilot for SaaS, anybody can go from 0 to 80% of a process diagram in minutes. Users can generate process diagrams from natural language descriptions. The simple interface means that even BPMN novices can make meaningful, accurate diagrams. And BPMN Copilot also generates a new version each time it creates a diagram, so you can see the progression of your process.

You can also feed documentation of a process, other vendor specifications and more to generate your BPMN diagram with Camunda Copilot.

BPMN to text with Camunda Copilot (SaaS only)

As we all know, documentation can be tedious to create and difficult to maintain with rapid iterations. With the 8.7 release of Camunda Copilot, you can not only generate BPMN diagrams, but you can also generate text from your BPMN diagram.

This offers a wide range of benefits including:

• Rapid draft of process documentation
• Faster enablement for how a process works
• Simpler explanation of process behavior to stakeholders

Ad-hoc sub-processes

With 8.7, we have introduced support of the BPMN element for ad-hoc sub-processes. This element is a collection of tasks that can be executed independently without predefined connections to other tasks in the process. This new process sets the stage for our support for agentic AI and AI agents, providing a compact visual representation and more flexible process flows―both deterministic and non-deterministic. AI agents enable you to increase the level of automation in a process, while BPMN provides guardrails for the use of AI models.

Reply scenarios

Play supports manual testing; however, this approach often leads to limited test coverage, lacks protection against regressions, and involves repetitive, error-prone tasks. However, with 8.7, you can now use Play to quickly repeat manual test suites by recording and playing back process instances as scenarios. As you save completed instances as scenarios, Play calculates the percent of elements covered by the scenario suite. This is the first step towards bringing automated testing into the Web Modeler and enabling business and IT to collaborate on automated tests.

REST API support of customer JWKS location and JWT algorithms

Self-Managed customers can now configure JWKS (JSON Web Key Set) location and JWT (JSON Web Token) algorithms manually. This is especially useful when the information cannot be derived from the OpenID configuration.

We hope you enjoy the latest Web Modeler 8.7 release!

Desktop Modeler

With our Camunda 8.7 release, we have provided support for the following features.

Support for upcoming features

Camunda 8.7 and 7.23 are now fully supported with Desktop Modeler.

Configure completion attributes for sub-processes

With the support of ad-hoc sub-processes, additional functionality has been added to support completion attributes. An ad-hoc sub-process can define an optional `completeCondition`―a boolean expression―that is evaluated every time an inner task or element is completed.

Support for process applications

We now support process applications and resource linking. You can use process applications to easily group and link processes, decisions, and forms in a project.

RPA editor

With the new RPA editor, users can edit, test, and deploy Robotic Process Automation (RPA) scripts.

Check out the full release notes for the latest Desktop Modeler 5.34 release right here.

Optimize

In this release, we have also worked on bug fixes and minor improvements for Optimize.

Console

Console self-managed: Tags and user-defined properties

We have added support for custom tags and properties in the self-managed Console to make it easier to manage orchestration clusters. Admins can now label clusters with tags like prod, dev, or test to identify them by environment quickly. These tags appear in the Console UI and can be accessed via the Administration API, helping with reporting and cost tracking.

Console self-managed: Inbound connectors monitoring

We’re introducing a new monitoring experience for inbound connectors to improve visibility and operational control. This release delivers a centralized view of all inbound connectors that are running for each Orchestration cluster managed within the Console.

We hope you enjoy the latest Console!

Installation options

This section gives updates on our installation options and various supported software components.

Self-Managed

Camunda 8 Run

Camunda 8 Run (C8Run) now supports additional configuration parameters, including web application port, location of keystore TLS certificates, and log level. With this release, we also introduced a new --docker option allowing you to start C8Run with the docker-compose up command and deploy Camunda 8 using Docker Compose instead of starting with a Java engine.

Reference architecture—Openshift dual region

We have published a Camunda dual-region deployment guide for OpenShift. This guide will allow our customers using OpenShift to develop active-passive configurations with failover and regional replication. For more information visit the documentation.

Kubernetes production guide

We’re excited to announce the Helm Chart Production Installation Guide. This comprehensive guide provides best practices and recommendations for running Camunda Self-Managed in production using Helm on Kubernetes. Whether you’re planning a new deployment or hardening an existing setup, this guide will help you optimize performance, reliability, and maintainability. Check it out here.

Support for user-defined manifests in Helm Charts

With this release, you can inject additional Kubernetes manifests directly through the values.yaml file. This feature is ideal for users who need to deploy custom resources—such as ConfigMaps, Deployments, or Services—alongside Camunda without modifying the Helm Charts themselves.

Task automation components

In this section, you can find information related to the components that allow you to build and automate your processes including our modelers and Connectors.

Connectors

With 8.7, document handling support has been added to over ten (10) connectors, allowing users to send documents via Microsoft Teams, Slack, or as email attachments. Documents can be uploaded to AWS or utilized with our AI connectors to gather additional insights into your process information. You can find more information in our documentation.

We’ve introduced intrinsic operations that enable users to work with documents easily and generate public links that are compatible with all connectors.

Inbound connectors now come with safer default settings to prevent multiple processes from starting in the event of duplicated messages.

We hope you enjoy the latest Connectors 8.7 release right here.

Document handling

Document handling has been updated for release 8.7 and now provides:

• Production support for 8.7
• Compatibility with both Amazon Web Services (AWS) S3 bucket storage as well as Google Cloud Provider (GCP) bucket
• A REST API that is available to manage and work with document operations:
  • Upload
  • Download
  • Delete
  • Create link

Intelligent document processing (IDP)

With 8.7, Camunda now offers intelligent document processing (IDP) enabling organizations to streamline and automate the handling of complex documents, minimizing manual errors and lowering operational costs. By integrating IDP into your process orchestration, you can enhance compliance, increase efficiency, and gain a competitive advantage.

Powered by AWS Textract and LLM technologies, intelligent document processing (IDP) helps you integrate automated document processing by extracting desired data fields and using them later into your end-to-end processes. You can train your IDP applications to extract certain data from different document types using an LLM extraction model.

Once configured, you can load various documents and test them against your configured extraction.

A connector is then created and can be used in various Camunda processes to extract data from documents providing deeper insights into the information provided.

This latest release provides the following:

• IDP is now supported in production with the release of Camunda 8.7.
• Allows for the configuration of your AWS region, AWS bucket name, and Camunda cluster while testing extraction.
• IDP provides support for JSON extracted fields.

Check out the getting started guide to get an early insight into the new feature.

Robotic Process Automation (RPA)

As mentioned earlier in this release blog, Camunda now provides Camunda RPA to create and execute integration with other systems seamlessly from your Camunda process.

Camunda focuses on creating micro RPA bots that simulate APIs, allowing you to automate interactions with legacy systems seamlessly. These bots serve as the glue between the legacy world and new digital environments.

Check out the getting started guide to get an early insight into the latest features.

Ecosystem

In this section, we provide release details for our various business solutions and product integrations. 

Camunda SAP Integration

With Camunda’s support for SAP, you can simplify your SAP transformations and increase business agility. Camunda offers SAP integration to provide the ability to integrate both SAP and non-SAP systems.

Our SAP integration has several modules to support the following functionality:

• Retrieve and write data to and from any SAP System (via OData and RFC)
• Start a Camunda process from any SAP System via an API
• Build one-user multi-page flow
• Generic SAP Business Technology Platform (BTP) Process Launcher to start Camunda processes in an SAP Fiori application during development
• Render Camunda forms in the SAP Fiori Design System as part of the one-user multi-page flow

This deep integration provides many benefits to our customers including:

• It is an SAP Certified integration.
• There are no additional licensing costs.
• Our integration is compliant with SAP’s Clean Core strategy.
• Camunda’s integration with SAP retains both SAP and BTP governance.

Camunda 7

With Camunda 7, we have added new features to improve the usability of Cockpit including:

• Operate with subsets of process instances.
• Filter processes with exceptions and retries left.
• Configure the default value for the cascade flag.
• Display business key for called process instances.
• Setting variable batch operation is now idempotent.

In addition, we now provide support for the FEEL Scala Engine as an integrated script engine.

We have added support for new environments as well including:

• PostgreSQL 17
• AWS Aurora PostgreSQL16
• Spring Boot 3.4
• WildFly 35
• Quarkus 3.20 LTS

The engine, by default, points to Spring 6 now.

Thank you

We hope you enjoy our latest minor release updates! For more details, be sure to review the latest release notes as well. If you have any feedback or thoughts, please feel free to contact us or let us know on our forum.

If you don’t have an account, you can try out the latest version today with a free trial.

Join us live to learn more!

Check out our companion release blog for additional information. You can learn more about recently released features in our upcoming webinar scheduled for April 10th at 11:00 AM ET / 4:00 PM CET. Register for the webinar to hear all about this release.

The post Camunda 8.7 Release is Here appeared first on Camunda.

As part of this commitment, we are excited to announce a significant evolution in our testing libraries: Camunda Process Test, designed specifically for Camunda 8.

Why the change?

Until now, Camunda 8 users have relied on the Zeebe Process Test (ZPT) library to unit test BPMN processes. ZPT served us well, leveraging an in-memory Zeebe engine with gRPC to run tests and verify process behavior.

However, as our platform evolved, ZPT could no longer fully support the latest Camunda 8 features, including our new REST API and user task functionalities. Additionally, as part of our API streamlining strategy, most of our gRPC endpoints will be phased out by version 8.10, making ZPT incompatible moving forward.

To address these challenges and provide our customers with enhanced testing capabilities, we’ve developed a completely new testing library: Camunda Process Test (CPT).

Introducing Camunda Process Test

The Camunda Process Test library is our next-generation testing framework, designed and built for our customers’ evolving needs. CPT offers powerful testing capabilities and fully aligns with the new Camunda 8 REST API, enabling comprehensive testing of BPMN processes, connectors, user tasks, and more.

Here are some highlights of what CPT offers:

• Improved developer experience: By leveraging technologies like TestContainers, CPT ensures faster test execution, simpler environment setup, and smoother integration into modern CI/CD workflows. Also, by using the in-memory H2 database as a secondary storage, the testing library keeps a small memory footprint.
• REST API integration: CPT fully integrates with the Camunda 8 REST API, providing extensive test coverage for the latest features, including Camunda user tasks, connectors, and advanced client commands.
• Enhanced assertions and test coverage: CPT provides a rich set of assertions and generates detailed test coverage reports after each test run. These enable developers to quickly pinpoint testing gaps and verify process behaviour more accurately.
• Automatic wait handling: CPT automatically manages process wait states, eliminating the need for manual waitForIdleState() or waitForBusyState() calls, significantly simplifying your test code.

Deprecation timeline for Zeebe Process Test (ZPT)

With the introduction of CPT in Camunda 8.8, we’re officially deprecating the Zeebe Process Test library. Here’s a clear timeline to help you plan your migration:

Camunda 8.8 (October 2025)

• Introduce CPT as the recommended testing library.
• Mark ZPT as deprecated (available but no longer actively enhanced).
• Provide a comprehensive migration guide and assertion mapping documentation.

Camunda 8.9 (April 2026)

• Transition: Both CPT and ZPT remain available and fully supported, allowing ample time for migration and testing.

Camunda 8.10 (October 2026)

• Fully remove Zeebe Process Test library from repositories and documentation.
• Customers must complete the migration to CPT before upgrading to 8.10.

Migration made simple

We understand that migrating to a new testing framework involves effort. To ensure a smooth transition, we’ll develop detailed resources, including:

• A comprehensive step-by-step migration guide from ZPT to CPT. It will include:
  • Clear mapping of existing ZPT assertions and utilities to their CPT counterparts
  • Practical example code snippets covering common migration scenarios
• Documentation featuring CPT’s new capabilities and best practices

These resources will be available together with the 8.8 release.

The migration involves the following steps:

1. Review existing test cases: Identify ZPT usage and custom assertions within your test suite.
2. Replace ZPT assertions with CPT equivalents: Use our assertion mapping guide for straightforward replacements.
3. Adapt to structural changes: Remove manual wait states and leverage CPT’s built-in automatic handling.
4. Migrate from Zeebe client to Camunda client: The Zeebe client is deprecated in favor of the Camunda client. CPT supports both clients until version 8.10.
5. Transition to TestContainers: Update local development environments and CI pipelines to use TestContainers, enabling consistent and fast test environments.
6. Utilize CPT’s enhanced capabilities: Leverage new test coverage reports, granular task lifecycle assertions, and improved connector testing.

Looking ahead

By transitioning to the Camunda Process Test, you’ll gain a more robust, flexible, and powerful testing framework aligned with the latest Camunda 8 features. While migration requires initial effort, the long-term benefits of improved test coverage, clearer assertions, and enhanced developer productivity are substantial.

We strongly encourage all customers to begin the migration process with the 8.8 release. Our documentation team and support resources will be ready to assist you in making this transition smoothly. Camunda documentation will provide detailed migration instructions and more information.

As always, we welcome your feedback and questions.

Happy testing!

The post Introducing Camunda Process Test—The Next Generation Testing Library appeared first on Camunda.

Simplified architecture for easy installation and getting started

Camunda 8.8 introduces a streamlined architecture that unifies core components—Zeebe, Operate, Tasklist, and Identity—into a single, production-ready distribution. By consolidating these components into a single deployable package, Camunda 8.8 reduces deployment complexity, simplifies resource configuration, and streamlines resource management. This approach makes installation and setup more straightforward, whether you’re preparing a production environment or just getting started with Camunda.

You can download the alpha release of the unified package as an executable Java application (Camunda Orchestration Core), available in our GitHub repository. For more information, we encourage you to watch this presentation from CamundaCon New York.

In earlier versions, each component of the Camunda Orchestration cluster—such as Zeebe, Tasklist, Operate, and Optimize—was deployed independently, either as separate deployments or within a StatefulSet (see Diagram 1). While Zeebe could support a fully distributed deployment model, components like Operate and Tasklist were often run as single instances. This previous approach added complexity, requiring individual scaling, configuration, and monitoring.

With Camunda 8.8, most components are merged into a single deployable package, available as a JAR file or Docker container. Optimize will continue to be deployed separately due to its architecture and importer requirements.

Camunda 8.8’s unified approach reduces the complexity of managing multiple independent services and minimizes the overhead involved. Additionally, the new exporter architecture (see Diagram 2) removes the need to deploy Operate, Tasklist, and Identity as separate services, further streamlining deployment.

This single deployable package simplifies resource configuration, management, and monitoring. For Kubernetes Helm deployments, starting from Camunda 8.8 alpha 1, Camunda Orchestration Core uses a single StatefulSet to run all components of the orchestration cluster. It consolidates computing resources into a single deployment, allowing for horizontal/vertical scaling while maintaining high availability (HA) and disaster recovery (DR) for all Camunda components. This approach reduces operational complexity, making it easier to manage and scale as needed.

The Identity component in Camunda 8.8 will also change how it is installed and configured:

• First, it will be integrated into a unified deployment package along with Zeebe, Tasklist, and Operate, streamlining deployment and reducing configuration complexity by bundling all major components together.
• Second, Identity will use Zeebe’s persistence storage instead of a PostgreSQL server, which enhances system consistency and reduces the need to manage additional databases.
• Third, Identity will be decoupled from Keycloak; while Keycloak is still supported, you can now use OpenID Connect (OIDC) to integrate directly with any compatible identity provider (IDP) of your choice. To learn more about the changes to the Identity component, please see the Identity blog post.

Upgrade Camunda 8.7 deployment to version 8.8

The upgrade path from version 8.7 to 8.8 is straightforward if you are using the recommended Camunda 8 deployment options—specifically, Helm Charts. Our charts will support the upgrade directly, simplifying the transition.

Additional upgrade considerations are necessary for deployments that use custom scripts, such as Docker containers, manual installations, or custom-developed Kubernetes deployments. In these cases, you can either continue to deploy with your original 8.7 topology and upgrade each component independently or adopt our Helm Chart approach for the upgrade, which allows for unifying the deployment into a single JAR or container executable.

With the 8.8 release, we’ll publish further guidance to help you upgrade from 8.7 to 8.8, providing detailed steps and best practices to ensure a smooth transition.

During the upgrade from Camunda 8.7 to 8.8 with Helm Charts, Zeebe will remain operational. However, minimal downtime may be required to migrate the Identity database. Operate and Tasklist may also require a brief downtime while these components are moved to a unified stateful set.

These interruptions are expected to be minimal. We recommend planning for this short downtime window to ensure that service disruptions are minimized and any impact is well managed.

Enhanced deployment options

Camunda 8.8 supports several deployment platforms, including Kubernetes (e.g., AWS EKS, Azure AKS, GKS, or OpenShift), manual installation (e.g., AWS EC2, VMWare VMs, etc.), container services (e.g., Docker Compose, AWS ECS, etc.), and local development using Camunda 8 Run or Kind.

Camunda 8.8 introduces a set of deployment reference architectures aimed at providing practical solutions for different deployment needs. These reference architectures are designed to help you understand and implement Camunda effectively based on your specific infrastructure requirements:

Kubernetes deployment with AWS EKS

This reference architecture outlines best practices for deploying Camunda on Amazon EKS. It covers infrastructure setup, resource scaling, and cluster management to ensure your Camunda environment is scalable and resilient. The architecture also provides guidance on integrating with other AWS services, such as AWS OpenSearch, AWS IAM, and HashiCorp Terraform.

Manual installation on AWS EC2

For organizations that do not use cloud-native platforms like Kubernetes or container services, this reference architecture provides guidance on implementing Camunda production clusters on AWS EC2 instances. It includes details on optimal instance sizing, network configurations, and security best practices to ensure robust performance and reliability.

While these provided reference architectures focus on specific platforms, we encourage you to use them as a foundation for deploying Camunda in their own unique environments or configurations. We plan to include detailed guides for Azure Kubernetes Service (AKS), OpenShift, and AWS container services in upcoming releases, providing more comprehensive deployment options for diverse infrastructures.

Kubernetes Helm Chart production deployment guide

With the 8.8 release, we plan to publish a new guide that explores the deployment of Camunda in Kubernetes. The guide will provide a detailed overview of the deployment process, including configuration options that enhance reliability, security, and scalability. It will also cover a variety of topics customers need to know to successfully deploy the Camunda Orchestration cluster in production.

Introducing Camunda 8 Run for pro developers

Camunda 8 Run, first released in version 8.6, is designed specifically for local development and testing, providing a lightweight setup without the need for a full-scale cluster. Camunda 8.8 will enhance C8Run to better meet the needs of professional developers:

• Local development and testing: Camunda 8 Run offers an easy way to run Camunda on a local machine, making it perfect for development and experimentation. It eliminates the need for a complex setup or a full Kubernetes cluster, allowing developers to get started quickly and focus on building and testing workflows.
• Integrated components: Camunda 8 Core Orchestration Cluster includes essential components like Zeebe, Operate, Tasklist and now Identity in one package. This integration ensures a seamless developer experience by providing all core functionalities needed for process automation in a single environment.
• Enhanced developer experience: By streamlining setup and bundling all necessary tools, C8Run helps developers iterate quickly, test new features, and validate workflows without the overhead of managing a distributed deployment.

Ideal use cases for Camunda 8 Run

Camunda 8 Run is perfect for local development and testing scenarios. It provides a lightweight setup that is easy to configure, making it an excellent choice for developers who need a fast and simple environment to build and experiment with process automation. Camunda 8 Run allows for efficient workflow testing without the complexity of managing high availability, failover, or scaling concerns, which are typically needed in production environments.

More sophisticated platforms—like Kubernetes or infrastructure as service (IaC) systems such as ArgoCD, Ansible, or Terraform—are recommended for production-grade deployments requiring advanced capabilities (e.g., high availability, enterprise-level security, and resilience). This makes Camunda 8 Run an optimal solution for rapid prototyping and local experimentation and for smoothly transitioning to full-scale production deployments using Camunda Orchestration Core.

Frequently asked questions about deployment in Camunda 8.8

What are the main differences between Camunda 8.7 and 8.8? 

Among other changes, Camunda 8.8 introduces a streamlined architecture, consolidating core components like Zeebe, Operate, and Tasklist into a single deployable unit, simplifying deployment and management.

It also provides enhanced deployment options such as new Kubernetes Helm guides, deployment reference architectures, and improved support for professional developers through Camunda 8 Run.

Can I use Camunda 8 Run for production environments?

Camunda 8 Run is primarily designed for local development and testing, providing a lightweight and easy-to-set-up environment. However, for those interested in running Camunda as a single deployable unit in production, we will soon publish a detailed guide on how to deploy the unified Jar file in a production setting.

This guide will provide the right way to leverage the benefits of a new architecture (such as simplicity of installation, as in the case of Camunda 8 Run) while ensuring scalability, high availability, and enterprise-grade security for production environments.

What deployment options are available for Camunda 8.8?

Camunda 8.8 can be deployed using Kubernetes with Helm Charts (e.g., AWS EKS, Azure AKS, or OpenShift), manually using a JAR on a VM or any other infrastructure platform, Docker Image (e.g., Docker-Compose or AWS ECS), or using C8Run, Docker-compose, or Kind for local development.

Will there be any downtime when upgrading from Camunda 8.7 to 8.8?

Zeebe might experience minimal downtime as it migrates Identity data into a new schema. Operate and Tasklist may experience small downtime while their pods are restarted with the new version. We recommend planning for this small window of potential downtime. More details will be outlined in the update guide published on the release date of Camunda 8.8.

The post Streamlined Deployment with Camunda 8.8 appeared first on Camunda.

As always, this is an alpha release, so you may encounter incomplete features. If you do, please let us know! You can share the issue on our forum or, if you’re an enterprise customer, let your AE or CSM know about the issue. This feedback helps our team as they work to finalize the features for the 8.7 release in April!

Requirements

Note: this configuration applies to an early-access alpha release of Camunda 8.7 and IDP. This configuration is likely to be different in the final 8.7 release.

There are a few requirements before you can start using IDP with Camunda. To get started, you’ll need API keys for Amazon Bedrock. Behind the scenes, Camunda connects to Bedrock to parse and understand the uploaded document. There are a few steps needed:

• First, you need to configure a user in AWS IAM that has permission to Amazon Bedrock, AWS S3, and Amazon Textract.
• Configure and save the access key pair for the IAM user. You need to save both the access key and secret access key.
• Create an AWS S3 bucket. It can be named whatever you want, but remember the name and region as they will be needed next!

Next, you’ll need to start an 8.7.0-alpha5 cluster with IDP enabled. IDP is only supported with 8.7.0-alpha5 in Self-Managed. SaaS alpha releases do not support IDP yet! (Support for SaaS will be included in 8.7, but is not available in this alpha.) IDP is also not supported in Desktop Modeler; you must use Web Modeler to configure and test IDP.

The easiest way to get started with IDP in Self-Managed is to use the Camunda 8 Docker configuration. Once you’ve downloaded the Docker Compose files, you will need to:

• Add the access keys, S3 bucket name, and region from AWS to the connector-secrets.txt file
• Add the access keys, S3 bucket name, and region to the docker-compose.yaml file in two different places:
  • Under the zeebe container, and;
  • Under the tasklist container

And that’s it! Now you’re ready to train Camunda on how to extract data from a document!

Training document extraction

Before you can use IDP in your processes, you need to define how data should be extracted from each type of document. The first step is to create a new IDP Application inside Web Modeler.

Select your alpha cluster and give your IDP application a name. Each IDP application will store a set of document extraction templates which will be used to extract data from an uploaded document. When you add an IDP connector to your process, you link it to an IDP application, just like you link a user task to a form. Camunda will match the document to one of the templates, then execute that template to extract the data.

Currently, IDP only supports unstructured data extraction. This method uses AI to understand a document’s structure and find the necessary data. In the future, Camunda will support a structured data extraction method that will allow data extraction from well defined data structures, such as XML or JSON documents.

For example, let’s build a customer invoice IDP application. First, we will create an unstructured data extraction called “Invoice PDF.”

The first step after creating the project is to upload sample documents. It is best to upload several different versions of the document you are trying to parse, to give Camunda enough data to accurately test against. By training the AI models against different variations of the document, it helps ensure that the model has the best chance at success.

After uploading a document, click on the “Extract” button to the right of it. The next screen might look a bit intimidating at first, so let’s break down the three major sections:

1. On the right side of the page, you will see a preview of the document you uploaded. If you uploaded multiple documents, you can preview each of them using the dropdown just above the preview. This makes it easy to reference the document itself while defining the fields to be extracted.
2. On the left is a list of fields to be extracted from the document. For each field, you give it a name (this is the name of the variable the data will be stored in, similar to how forms work), a data type, and a prompt that tells the AI what to extract from the document.
3. Finally, there is the extraction model and a couple of buttons. The extraction model dropdown gives you a choice between multiple available AI models available in AWS; the “Extract document” button tests your prompts against the previewed document; and last, you can save the configuration as a test case.

The prompt you create for each field is the same type of prompt that you might give ChatGPT. In many ways, creating prompts is a skill that needs to be learned and practiced. For the simple example in the screenshot, the prompt of “find the name of the person who this invoice is for” might not be the most eloquently stated English sentence, but it is a prompt the AI understands fairly consistently.

Looking for more information about AI prompting? Check out this blog post!

You might be wondering why we offer multiple models. There are two primary reasons: cost and compliance. As enterprises adopt AI, they may have policies that restrict which models can be used. Different models also have different costs. You will likely find that you need different models for different documents. Each model has its own strengths and weaknesses, and there is no prescription here: test your model and refine your prompts to get the results your process needs. Camunda offers multiple models to allow you and your enterprise to find the right balance between capability, cost, and compliance. (Coming up on the roadmap is allowing enterprises to bring their own model!)

When you’ve finished adding a few fields and have selected a model, click the “Extract document” button to test your prompts. For each field you added, you should see the expected value in the “Extracted value” text box. If you are getting different data, try refining your prompt.

Creating a test case

Once you’re satisfied with the results of the extraction, it is time to save this data set as a test case. A test case makes it easy to test the model against multiple documents and ensure you are getting the level of consistency you expect.

How is this different from the “Extract document” test, you might be wondering? The previous test worked against the single document selected in the preview; this step runs against all the sample documents uploaded! It also validates the data extracted in the previous step against the data extracted during the test to ensure they match. (In other words, it is checking the newly extracted data against the data saved in the previous step to ensure accuracy.)

After selecting the AI model you want to use, click the “Test documents” button and review the results. You can expand each field and view the extracted value for each of the test documents. If you find yourself getting inconsistent or incorrect results, you will need to go back to the “Extract data” step and further refine your prompts.

You’ll notice in this screenshot that the total field did not get the same values as the test case. This is because I used a different model to test with (Claude 3.5 Sonnet instead of Llama 3 8B Instruct). In order to resolve this issue, I can choose to move forward with the Llama 3 model, or I can go back to the “Extract data” step and refine my prompts to work better with Claude.

Once you are satisfied with the results, click the “Publish” button and select “Publish to project.” Here you can give your IDP application a version and description, as well as select which model will be used to extract the data. Similar to how connector templates work, after you’ve developed it, you must publish it so that you can use it within processes.

Adding IDP to a process

There are two important things to consider when adding IDP to a process: first, you need a way to upload a document; and second, you need to use the new “IDP Extraction Project” task type.

There are two ways to upload a document to a running process:

• You can use the REST API to upload a document (or multiple documents!), or;
• You can use the file picker inside a Camunda Form.

For this example, I built the simplest possible form in Web Modeler with only a file picker. I gave the file picker the key of document, so I know that is the variable name that will store the uploaded document(s).

Next, I added a task for document processing. If you scroll all the way to the bottom of the “Change element” list, you will see a new section below the connectors called “IDP Extraction Project.” You should see your published IDP application here. Select it!

You’ll notice in the details pane that some secrets are automatically populated. If you changed the name of the connector secrets when configuring your cluster, you will need to remember to change the name here too! Be sure to check all of the fields to make sure they match how you’ve defined your process and data (of course, don’t forget to define your variable output handling too!):

• Authentication: ensure that the proper connector secrets are set.
• AWS Properties: ensure that the AWS region for your S3 bucket is set.
• Input Message Data:
  • The “Document” field should reference whatever variable you stored the uploaded document in. For my example, I used the key name document. Document uploads via the file picker are a list, so we need to ensure we are getting the first element of that list by setting this field to document[1].
  • The “AWS S3 Bucket Name” field should be the name of the S3 bucket you configured earlier. By default we assume the name is “idp-extraction-connector.”

And that’s it, you’re ready to run and test your process!

Exciting things ahead!

If you want to see IDP implemented end to end, showing the file upload and parsing of the document, check out this fantastic introduction video from our Senior Developer Advocate, Niall Deehan!

Curious for what else is coming in 8.7? Check out the latest alpha release blog for 8.7.0-alpha5! Ready to start experimenting with agentic AI? Learn about some essential BPMN patterns for agentic AI, and then build your own agent! And as always, if you have any questions, join our community forum!

Happy orchestrating!

The post Camunda 8.7 Preview: Intelligent Document Processing appeared first on Camunda.

In short, Camunda 8.8 brings these key changes to identity management:

• Cluster-level identity management
• Decoupling from Keycloak
• New resource-based permissions
• Enhanced REST API endpoints

These architectural adjustments in Camunda 8.8 offer several clear benefits:

• Flexibility: Camunda 8.8 will offer limited built-in user management functionality, eliminating the need to run Keycloak. Users requiring a more feature-rich identity provider can seamlessly integrate their own identity provider (IdP) through OpenID Connect (OIDC).
• Enhanced control: With identity and user groups managed within each cluster, organizations gain more precise control over user access.
• Security: The principle of least privilege ensures that access is tightly controlled, reducing the risk of unauthorized actions.
• Granularity: Resource-level permissions provide a level of customization that enables you to fine-tune access at every level.

Key changes in Camunda 8.8 Self-Managed

Camunda 8.8 introduces significant advancements to streamline installation, configuration, identity management, and REST API capabilities, further enhancing user flexibility and control.

Removing Keycloak

A notable change is the removal of the built-in Keycloak integration, which grants users more freedom in selecting their preferred IdP. While Keycloak is still fully supported as an external option, Camunda 8.8 enables users to integrate any compatible IdP, providing greater customization and alignment with organizational standards. OIDC remains the standard for seamless integration with chosen providers.

No requirement for relational database

Beyond rethinking identity management, Camunda 8.8 simplifies installation by removing the requirement for a relational database in single orchestration clusters, reducing complexity and making the setup more user-friendly. Identity settings are now configured at the orchestration cluster level, allowing each cluster to have unique OIDC configurations.

This cluster-specific setup empowers organizations to assign different IdPs across clusters, offering improved control over permissions and user group mappings, resulting in a more streamlined and efficient configuration experience.

New identity-focused endpoints

Camunda 8.8 introduces new identity-focused endpoints within the Camunda 8 REST API, providing enhanced query capabilities for managing process entities, such as processes, decisions, user tasks, and forms. This marks the beginning of a shift from component-specific APIs (like Tasklist and Operate) to unified, centralized queries.

The Camunda 8 REST API endpoints enable managing users and permissions within orchestration clusters, supporting resource-based authorizations for fine-grained access control. This approach strengthens control over resource access, building a secure, scalable foundation for customizable workflows across various organizational needs.

Embracing the principle of least privilege

Camunda 8.8 also introduces a stricter adherence to the principle of least privilege, a core security practice. When authorization is enabled, users do not have default access to applications like Tasklist and Operate, or to any resources. Permissions must be explicitly granted, ensuring that users only have access to what is necessary.

We’re also introducing resource-level permissions, applying to process definitions and web applications. Admin users will continue to have full access, but regular users will need to be granted specific permissions to perform actions or view resources. For organizations that build custom frontends and access Camunda via API, users with API permissions can still access process data through the API.

Managing identity in SaaS

For our SaaS customers, identity management in Camunda 8.8 remains consistent with Camunda 8.7, allowing the attachment of a single IdP per organization. However, we are extending cluster-level identity capabilities to SaaS as well. This means that user groups, roles, and access permissions can now be managed at the cluster level, giving SaaS customers the same granular access control as in Self-Managed environments.

Elevating identity management

Camunda 8.8 marks a major step forward in our Identity service. By moving to a more flexible architecture and offering deeper control at the cluster level, we’re enabling our users to better manage their identity and access needs. Whether you’re in a Self-Managed environment or utilizing our SaaS offering, the upcoming release ensures a smoother, more secure experience for all users.

Stay tuned for the official release, and get ready to take advantage of these new features!

The post Introducing Enhanced Identity Management in Camunda 8.8 appeared first on Camunda.

Please note that we have again released two alphas this month: 8.7.0-alpha5 and 8.8.0-alpha2. Below is a summary of everything new in Camunda for this March 2025 alpha release.

Introduction to the new release blog

We introduced a new format for our monthly release blog a few months ago. As a reminder, this format organizes the blog using the following product house, with E2E Process Orchestration at the foundation and our product components represented by the building bricks. We have organized our components as per the image below to show how we believe Camunda builds the best infrastructure for your processes, with a strong foundation of orchestration and AI thoughtfully infused throughout.

E2E Process Orchestration

This section will update you on the components that make up Camunda’s foundation, including the underlying engine, platform operations, security, and API.

Zeebe

Zeebe engineers have been contributing to streamlining future functionality during this release cycle.

Operate

Our Operate engineering team has been working on bug fixes for this release cycle.

Tasklist

There are no major changes for Tasklist this month. The focus has been on stability improvements, addressing minor bugs, and optimizing performance to enhance overall reliability. Stay tuned for upcoming enhancements!

Web Modeler

With this alpha release of Web Modeler, we have several new features.

Project landscape visualization (0.1)

Project landscape visualization makes it possible to visualize the end-to-end process through a hierarchical view of all related processes, enabling better decision-making and strategic alignment. This feature is released for SaaS and Self-Managed.

Process application versioning

You can now create versions of your process applications, tracking changes and ensuring the right version of the applications are deployed to the right environment.

Process Application Review: Governance (SaaS only)

Our Web Modeler formal review process now provides stronger governance and change control with Web Modeler to ensure safe production deployments for processes with low to medium complexity and criticality.

This second iteration provides a setting to enable production deployments from the Web Modeler UI if the process application has been reviewed as an alternative to using your own deployment pipeline.

Play support for multi-tenancy

With this alpha release, Play now supports multi-tenancy in Self-Managed.

BPMN to text with Copilot (SaaS only)

Documentation is tedious to create, and difficult to maintain with rapid iterations. With this alpha release of Camunda Copilot, you can not only generate BPMN diagrams, but Camunda now offers support to generate text from the BPMN diagram.

This offers many benefits including:

• Rapid draft of process documentation
• Faster enablement for how a process works
• Simpler explanation of process behavior to stakeholders

We hope you enjoy everything in the latest Web Modeler 8.7.0-alpha5/8.8.0.alpha2 release!

Desktop Modeler

We are supporting several new features with Desktop Modeler with our latest alpha release.

Support for upcoming Camunda 8 features

You can now create diagrams for Camunda 8.8. We also added support for an updating user task listener.

Better modeling guidance

With this alpha, we have improved our validation of Camunda 8 ad-hoc sub-processes. In addition, customers can now provide their own documentation URLs for validation rules via the core infrastructure provided by linter plug-ins. The modeler picks up these URLs and displays them for error reports.

BPMN modeling improvement

You can now find elements using Camunda-specific search terms and change the event type without losing its implementation details.

Check out the full release notes for the latest Desktop Modeler 5.33 release right here.

Optimize

With this alpha release, we have added support for ad-hoc sub-processes into Optimize and worked on various bug fixes.

Unified REST API

Number-based key attributes

For our 8.8.0-alpha2 release, number-based key attributes have been removed from the API to eliminate possible confusion and keep the API clean.

Camunda Java SDK

The Zeebe Java client is now the Camunda Java SDK, featured in the Camunda Spring SDK and used in all internal downstream components. It replaces and extends the Zeebe Java client while preserving the same behavior for commands that exist in the Zeebe Java client. This enables us to support not only Zeebe, but our other products as well like Operate, Tasklist, etc.

Identity

For our 8.8.0-alpha2 release, we have introduced Orchestration Identity’s first end-to-end journey with basic authorization only.

Console

In this release, we worked on future functionality, bug fixes, and minor improvements for Console.

Installation Options

This section gives updates on our installation options and various supported software components.

Self-Managed

Helm charts

With the Helm Chart alphas, we have developed a production-focused deployment guide that provides a step-by-step approach to deploying Camunda 8 in a resilient and production-ready manner. This guide minimizes complexity while establishing a reliable foundation for most production use cases.

We have expanded our support to enable Document Handling for both GCP and AWS, and have upgraded to Keycloak version 26.

Additionally, we have completed a guide for setting up the necessary infrastructure to run Camunda 8 on Red Hat OpenShift on AWS (ROSA), supporting both single-region and dual-region deployments.

Camunda 8 Run now offers greater configurability, including support for customizable parameters such as ports, TLS, keystore, the option to disable Elasticsearch and more.

Task Automation Components

In this section, you can find information related to the components that allow you to build and automate your processes including our modelers and Connectors.

Connectors

Our document handling has several new features related to connectors:

• Our SendGrid connector now supports document attachments.
• Our Google Drive connector now supports document upload and download.
• Documents can now be used with our Textract connector.
• You can now add attachments to Slack using our Slack REST connector.
• You can configure the proxy using environment variables or system properties, which will then be used by the REST connector.

We hope you enjoy everything in the latest connectors releases 8.7.0-alpha5 and 8.8.0-alpha2.

Intelligent document processing (IDP)

With this release, we have introduced an early version of our newest Intelligent Document Processing (IDP) feature.

Powered by AWS Textract and LLM technologies, Intelligent document processing (IDP) helps you integrate automated document processing by extracting desired data fields and using them later into your end-to-end processes.

With this version, you can:

• Create an IDP application that will allow you to configure, test and publish extraction projects.
• Validate your extraction configurations by saving documents as test cases.
• Integrate IDP into your existing processes.

Check out the Getting started guide to get an early insight into the upcoming feature.

Full support for this feature will start from the 8.7 minor release onwards.

Robotic Process Automation (RPA)

With this release, we have introduced Robotic Process Automation (RPA) as part of the Camunda stack. With this version we support for the following:

• You can create RPA scripts and do local testing within Desktop Modeler.
• You can deploy and manage RPA files in Zeebe.
• RPA tasks are now available within BPMN diagrams for automation.

Check out the Getting started guide to get an early insight into the upcoming features.

Business Solutions

In this section, we provide release details for our various business solutions and product integrations. 

Camunda 7.23.0-alpha4

For information on the latest updates to Camunda 7, please refer to the post in our forum.

Thank you

We hope you enjoy our latest minor release updates! For more details, be sure to review the latest release notes as well. If you have any feedback or thoughts, please feel free to contact us or let us know on our forum.

If you don’t have an account, you can try out the latest version today with a free trial.

The post Camunda Alpha Releases for March 2025 appeared first on Camunda.