8.10 Release notes
Release notes for new features included in the 8.10 minor release, including alpha feature releases.
| Minor release date | Scheduled end of maintenance | Changelog(s) | Upgrade guides |
|---|---|---|---|
| 13 October 2026 | 11 April 2028 | Patch Releases and Changelogs | 8.10 upgrade guides |
- See What's new in Camunda 8.10 for important changes to consider when planning your upgrade from Camunda 8.8.
- See release announcements to learn more about supported environment changes, breaking changes, and deprecations.
- Refer to the quality board for an overview of known bugs by component and severity.
Technical Changelogs for all 8.10.x releases
Overview of all patch releases and their Changelogs in GitHub
8.10.0-alpha3
| Release date | Changelog(s) | Blog |
|---|---|---|
| 14 July 2026 | - |
Agentic orchestration
AI agent testing assertions in Camunda Process Test
You can now test non-deterministic AI agent behavior in Camunda Process Test (CPT) with conditional behavior controls and evaluation-based assertions. With this, you can validate agent behavior and output quality with clearer, more reliable test outcomes.
- Define conditional behavior in tests with a
when(condition).then(action)API for activation-based flow control. - Assert output quality with LLM-as-a-judge expectations when exact matching is not enough.
- Assert semantic similarity with embedding-based comparison for responses that vary in phrasing.
- Configure remote or local models through code and properties for both local development and CI/CD pipelines.
APIs & tools
Public Hub REST API
Camunda Hub now provides a public REST API under /v2/ for programmatic access to Hub resources. The API aligns with the Orchestration Cluster API guidelines, with standardized error handling and data-fetching patterns.
The Console Self-Managed and Web Modeler APIs are deprecated in favor of the public Hub REST API. See the release announcement for details.
Camunda Hub
Bespoke cluster generations for SaaS
Organizations can now access exclusive Camunda 8 generation versions tailored specifically for their organization, available for both new cluster creation and upgrades. These generations are not visible to other organizations.
Git-based catalog
Camunda Hub introduces an organization-level catalog for reusable, Center of Excellence (CoE)-approved assets, such as element templates, connectors, forms, and DMNs, backed by source control management (SCM).
CoE teams can submit assets through the API from their SCM workflows, and delivery teams can browse catalog entries in Hub and inspect asset details. This release also adds in-diagram notifications for updated shared assets and pre-deployment dependency checks that surface missing DMNs, forms, connectors, and other dependencies on the target cluster before deployment.
Select a target version when upgrading a cluster
When you upgrade an Orchestration Cluster that has more than one valid upgrade target, Console now shows a version selection step in the upgrade wizard. Each option displays the generation name and the Zeebe patch version.
The recommended version (the longest upgrade path) is pre-selected and labeled latest, and you can choose a different option before proceeding. Clusters with only one upgrade target keep the existing flow.
Modeler
Safe deletion with a 30-day recovery window
Deleting an item in Web Modeler no longer removes it immediately. Deleted projects, files, folders, process applications, and IDP applications are moved to Recently deleted for 30 days. During that time, users with the appropriate permissions can see who deleted an item and when, and restore it. After 30 days, items are permanently deleted.
Deletion no longer corrupts process application version history, as existing snapshots continue to reference deleted files correctly. The recovery window applies to deletions made in 8.10 and later; items deleted before upgrading cannot be recovered.
Test process segments in Play
When testing your process with Play in Web Modeler, you can now capture and rerun targeted sections of an agentic process as low-code integration tests:
- Run segment tests individually or in batches to validate process changes faster.
- Test BPMN elements like connectors, DMN, forms, and LLM tasks without a full end-to-end run.
- Reuse saved segment tests during iterative model changes to catch regressions earlier.
Variables panel improvements
When you hover over "written in X elements" or an element ID in the variables panel, the diagram now highlights the corresponding element or elements so you can quickly see where a variable is used.
FEEL expressions in the variable outline now use the same syntax highlighting as the FEEL editor, with more granular tokens that distinguish function names from arguments and operators from literals, making complex expressions easier to read.
Operate
Multi-variable filtering
In Operate, you can now combine multiple variable filters with AND logic to find exactly the process instances you need.
Filter by variable name, value, and comparison operators, such as equals, contains, greater than, and less than, including nested JSON paths.
Wait states
Operate now shows what an active process instance is waiting for. When you inspect an active element, you can see the wait state and its details, for example, a timer's due date, a receive task's message name and correlation key, a signal name, a condition expression, or a job's type and state.
Wait state tracking is enabled by default and writes records to secondary storage. In Camunda 8 Self-Managed, you can disable it if you do not want to track this data.
Camunda Hub
Self-service restore for SaaS orchestration clusters from backups
Organization admins can now restore a SaaS orchestration cluster directly from a completed backup in Console and through the Administration API.
Key benefits:
- Reduced time to recovery for operational incidents.
- Operational control without opening a support ticket for standard same-cluster restores.
- Clear restore status visibility during execution.
This release supports in-place restore for the same cluster only. During restore, the cluster is unavailable until completion.
Known limitations:
- Same-cluster restore only.
- Partition count must match between backup and target cluster.
- Cross-region and cross-cluster restore are not supported in this release.
Learn more:
Optimize
Optimize disabled by default on new trial clusters
On new trial clusters in Camunda 8 SaaS, Optimize is now disabled by default. When Optimize is disabled, the overview shows a muted tile with an Enable Optimize prompt so it stays discoverable.
Upgrading from a trial to a paid plan automatically enables Optimize, with no manual action required.
Orchestration Cluster
Archive by ID for Elasticsearch and OpenSearch
Archiving of finished process instance data in Elasticsearch and OpenSearch secondary storage now uses a targeted, incremental approach by default.
Documents are moved in small, targeted batches rather than in a single operation, improving stability and reducing resource pressure during archiving. The rolloverBatchSize and reindexBatchSize properties control how many process instances and individual documents are processed per batch.
Async replication support for RDBMS secondary storage
Camunda 8.10 adds first-class support for asynchronously replicated relational databases as secondary storage, including AWS Aurora and PostgreSQL.
The exporter layer detects when the active RDBMS endpoint is unreachable, including during a standby promotion or cross-region failover, and pauses export operations automatically rather than entering an error state. Export position is preserved in the Zeebe log and replayed on reconnection.
After failover, a reconciliation path replays missing events from the Zeebe log to close any replication lag gap, restoring a consistent secondary storage state without manual data repair. A single-exporter configuration is now supported for deployments where the RDBMS handles cross-region replication natively.
Dual-region ECS reference architecture
Camunda 8.10 adds a dual-region reference architecture for running the Orchestration Cluster and Connectors on AWS ECS with an RDBMS secondary storage such as Aurora Global Database.
The documentation covers the recommended topology, exporter configuration, and RDBMS replication setup, and includes step-by-step failover and failback procedures for active-active and active-passive two-region ECS environments.
Dual-region ECS reference architecture
Multi-tenancy support in SaaS
Camunda 8 SaaS now supports multi-tenancy via tenant identifiers, bringing the same logical tenant isolation model available in Self-Managed to SaaS clusters.
- Owners and Admins can create, update, and delete tenants in Console, and assign users, groups, and client credentials to them.
- Web Modeler and Desktop Modeler support tenant-scoped deployments to multi-tenant clusters by specifying a tenant ID.
- Tenant usage is reflected in Console reporting so org owners can monitor tenant consumption across a cluster.
Multi-tenancy is enabled at the cluster level. Process definitions, instances, and decisions are scoped to the tenant they were deployed to, keeping data isolated across teams and applications sharing a single cluster.
New RDBMS version support
Camunda 8.10 adds support for new relational database versions. Operators running Self-Managed Camunda clusters can upgrade their database layer to the latest supported versions without disruption to running process instances.
New supported versions include Amazon Aurora PostgreSQL 18, MariaDB 12.3, Microsoft SQL Server 2025, and MySQL 9.7.
Physical Tenant support
Camunda 8.10 introduces Physical Tenant support for RDBMS, enabling strong isolation across tenants.
- The REST API and gRPC API are exposed per Physical Tenant, with
CamundaClientsupporting Physical Tenant selection in the gRPC API. - Web apps (Operate, Tasklist, and Admin) are accessible per Physical Tenant at
<baseurl>/physical-tenants/<physicalTenantId>/<webapp>. - Authentication is configurable as
basic author OIDC at the cluster level, with support for multiple OIDC providers assigned to individual Physical Tenants.
Physical Tenant isolation model
Select a DMN version with a FEEL expression
You can now call a dynamically calculated version of a DMN decision from a BPMN business rule task by specifying the version with a FEEL expression.
Region-aware partition placement
Camunda 8.10 introduces region awareness to the Orchestration Cluster. Operators declare which region each broker belongs to using a topology label, and the engine uses those declarations to distribute partition replicas across regions, ensuring no single region holds a quorum for any partition.
Leader election priorities respect region boundaries, preferring region-local leaders under normal conditions and adjusting automatically when a region becomes unavailable. The same mechanism extends to availability zone or datacenter isolation using the same configuration.
Orchestration Cluster configuration properties
Helm chart deployment
Docker images
Camunda no longer produces the following Docker images in Camunda 8.10 and later, or in Camunda 8.9 from patch release 8.9.12:
Use the unified camunda/camunda Docker image instead.
8.10.0-alpha2
| Release date | Changelog(s) | Blog |
|---|---|---|
| 09 June 2026 | - |
Agentic orchestration
Skills repository for pro-code AI enablement
The Camunda Skills repository toolset enables AI coding agents to build, validate, and configure Camunda artifacts. With the Skills installed, your AI agent can:
- Build and modify BPMN diagrams with a human-readable layout.
- Configure connectors using element templates (no raw XML).
- Generate form schemas with validation.
- Create and edit DMN decision tables.
- Run BPMN lint rules against generated diagrams.
- Scaffold and wire Camunda Process Test (CPT) integration tests.
Judge assertions in CPT JSON Test Cases
Camunda Process Test (CPT) now supports judge assertions in JSON test cases.
- Define judge assertions using JSON test case instructions.
- Use a preconfigured judge from
camunda-container-runtime.propertiesor Spring application properties depending on the test execution context.
Processes MCP Server
AI agents can use the Processes MCP Server to discover and call deployed BPMN processes as Model Context Protocol (MCP) tools.
When you deploy a process with an MCP start event it is automatically registered as a callable tool. MCP clients connect to the /mcp/processes endpoint and can invoke any registered process, with the Orchestration Cluster starting a new process instance and immediately returning the process instance key.
The server also exposes static tools for inspecting running process instances, so agents can check variables, state, and incidents without switching servers.
APIs & tools
Camunda 8 Run no longer requires Java
Camunda 8 Run now includes a bundled Java runtime. This means you no longer need to install OpenJDK or set JAVA_HOME before starting Camunda 8 Run.
FEEL evaluation with process instance key
The POST /v2/expression/evaluation endpoint now optionally evaluates expressions in the context of:
- A process instance, via
processInstanceKey. - A flow node instance, via
elementInstanceKey.
The endpoint:
- Combines process instance variables, element-local variables (for element scope), cluster variables, and optional request context into a single evaluation context.
- Enforces
EXPRESSION:EVALUATEplusPROCESS_DEFINITION:READ_PROCESS_INSTANCEon the underlying process definition. - Requires exactly one of
processInstanceKeyorelementInstanceKey(mutually exclusive); sending both returns400 Bad Request.
Behavior remains free from side effects and uses the same timeout and guardrails as the existing cluster-scope evaluation.
Removal of deprecated APIs, Zeebe Client, and Zeebe Process Test
The deprecated Operate and Tasklist APIs are removed. Process data, task management, and operational queries are now served through the Orchestration Cluster API.
Migrate to the Orchestration Cluster API
The Zeebe Client is removed and replaced by the Camunda Java Client. This covers process deployment, message correlation, and job handling.
Migrate to the Camunda Java Client
The Zeebe Process Test library is removed and replaced by Camunda Process Test. This provides richer assertions, Spring integration, and alignment with the Orchestration Cluster API surface.
Migrate to Camunda Process Test
Modeler
Support for start forms in Desktop Modeler
Desktop Modeler now supports defining form references on none start events in Camunda 8 BPMN models, matching the existing Web Modeler capability.
You can configure start forms directly in Desktop Modeler's properties panel using:
- Camunda Form (linked): Reference a deployed Camunda Form by ID.
- Camunda Form (embedded): Embed form JSON in the BPMN diagram (deprecated).
Start forms can now be defined and edited in both modelers, ensuring a seamless experience when working with diagrams across Web Modeler and Desktop Modeler.
Orchestration Cluster
Default RocksDB memory allocation strategy changed to FRACTION
The default RocksDB memory allocation strategy changes from PARTITION to FRACTION. RocksDB memory is now allocated as a fraction of total available memory (default 0.1, or 10%) instead of scaling with the number of partitions per broker. This may result in a different amount of memory being allocated to RocksDB.
To keep the previous behavior, explicitly set the strategy to PARTITION. See the release announcement for more details.
Optimize
Scope-aware variable export configuration for Optimize
You can now configure variable export behavior by scope:
- You can enable or disable root (process instance) variables and local variables independently.
- You can exclude all local variables by default, while still allowing specific local variables by name pattern.
- Configuration integrates with the existing variable filtering mechanism, using consistent syntax and semantics.
Terminology aligns with Camunda 8 docs:
- Root scope/process instance scope: Variables visible across the process.
- Local variables: Variables defined in child scopes only.
With this, you can configure setups such as:
- Export only root variables for all processes.
- Export a curated subset of local variables (for example,
taskContextDisplayNameor specific local audit variables) without exposing all locals.
8.10.0-alpha1
| Release date | Changelog(s) | Blog |
|---|---|---|
| 13 May 2026 | - |
Agentic orchestration
AI Agent connector: Conversation storage SPI redesign
The conversation storage SPI used by custom AI Agent storage backends has been redesigned. Built-in stores are migrated transparently; custom ConversationStore implementations must be updated.
See the release announcement for more details.
Camunda-provided LLM for SaaS
You can now run any AI Agent on Camunda 8 SaaS in minutes using the Camunda-provided LLM, without wiring your own LLM credentials. Whether you start from a Camunda-provided agentic blueprint or build your own agent from scratch, the required credentials are populated automatically as cluster secrets, so there is little to no extra setup needed to get started.
The included budget is sufficient for hundreds or thousands of agent runs even on a trial account, depending on the model used. For enterprise organizations, AI features must be enabled first; after that, Camunda-provided LLM is enabled automatically.
This dramatically reduces time-to-first-running-agent by removing the need for external LLM infrastructure or credential setup on day one.
MCP start event element template
The MCP start event element template is now available in Web Modeler and Desktop Modeler. Apply it to a BPMN message start event to configure the process as an MCP tool with name, purpose, inputs, and usage guidance for LLMs.
See MCP start event for the full property reference.
Standalone evaluation assertions for judge and semantic similarity
Camunda Process Test now exposes judge-based evaluation and semantic similarity evaluation as standalone AssertJ assertions for arbitrary string values, without requiring process-variable assertions. Semantic similarity checks support configurable embedding models and thresholds, and both assertion types reuse the existing CamundaAssert configuration with optional local overrides.
Camunda Hub
Usage & billing metrics for 2025 enterprise license model
Camunda Hub and Accounts now support the 2025 enterprise license model.
- A new
licensing_modelattribute onOrganizationMetaDataidentifies if an enterprise organization is using the 2025 or legacy license model. If unset, it is treated as legacy. - If you are an organization with
licensing_model = 2025, your Usage and Billing views only show Process Instance (PI) metrics. Decision Instance (DI) and Unique Task User (TU) information is no longer shown. Legacy organizations continue to see the existing metric set. - For enterprise (
salesplantype = enterprise) organizations, the licensing model is shown in the organization details. Admins can edit this by selecting either legacy or 2025 via a modal action. - The enterprise onboarding wizard now includes a license selection step (defaults to 2025). The
ExternalOnboardingRouteraccepts an optional licensing model parameter (defaulting to 2025 if not provided).
Cluster version selection for SaaS Orchestration Clusters
You can now create new SaaS Orchestration Clusters on specific supported Camunda 8 minor and patch versions, including:
- The latest recommended versions (latest patch of each active minor)
- Other still-supported versions that you already run on existing clusters in the same organization.
Intelligent document processing (IDP)
Support for ABBYY as an IDP Provider
Camunda IDP now supports ABBYY as a document extraction provider.
Modeler
Support for configurable headers for execution listeners
Execution listeners now support configurable headers, aligned with service task job headers.
- In BPMN, execution listeners can define
<zeebe:taskHeaders>. The headers are passed to the listener’s job worker alongside any base-element headers, with listener headers overriding on key conflicts. - In Modeler, you can configure execution listener headers visually (name/value pairs) without editing BPMN XML.
- Listener workers can consume these headers as metadata and configuration parameters using the same patterns as service task job workers.
Integrations
Microsoft Teams routing and permission-aware task actions
Camunda for Microsoft Teams now supports routing incident and task collaboration to private channels, shared channels, and group chats. Notifications and task actions in Teams now align with Camunda assignment and access rules, ensuring that only eligible users are notified and allowed to act.
Operate
JSON display in Operate
Camunda 8.10 introduces an update to the JSON display functionality in Operate (SaaS).
You can now:
- Open JSON variables in a dedicated JSON viewer directly from the variables panel, without entering editing mode.
- View JSON values with consistent, easier to understand formatting.
- Copy full JSON variable values to the clipboard.
- Use the improved in-line variables display.
This change helps navigate more complex data during operations and troubleshooting.
APIs & tools
In-memory OAuth credentials cache by default for the Java client
The Camunda Java client now caches OAuth credentials in memory by default. The file-based cache at $HOME/.camunda/credentials is no longer enabled out of the box and is available as an explicit opt-in.
Why this change:
- The previous default tried to create
$HOME/.camunda/credentialson first use. In hardened container environments — non-root users (KubernetessecurityContext.runAsUser, OpenShift), read-only root filesystems, immutable images — this raisedAccessDeniedException/IOExceptionat first cache write. Affected users had to apply a non-obvious workaround (mount a writable volume and point an environment variable at it) just to get a client to start. - Memory-only caching removes that footgun: clients work out of the box in any deployment topology, and the in-process token cache plus proactive refresh still avoid unnecessary token endpoint calls during a JVM's lifetime.
- The file cache had also been a source of latent corruption when multiple JVMs shared the same
$HOME; making it opt-in restricts its use to deployments where persistence across restarts is genuinely needed.
How to opt in to the file-based cache (behavior identical to pre-8.10):
- Java client builder:
new OAuthCredentialsProviderBuilder().credentialsCachePath("/path/to/cache"). - Spring property:
camunda.client.auth.credentials-cache-path: /path/to/cache. - Environment variable:
CAMUNDA_CLIENT_CONFIG_PATH=/path/to/cache(orZEEBE_CLIENT_CONFIG_PATHfor the legacy Zeebe client).
If you previously set CAMUNDA_CLIENT_CONFIG_PATH / ZEEBE_CLIENT_CONFIG_PATH only to work around the non-root container error, you can now remove that configuration and rely on the in-memory default.
Spring Boot starter configuration
Orchestration Cluster
Cancel execution listener
Execution listeners now support a cancel event type on the process element. Cancel listeners run when a process instance is terminated — useful for cleanup, audit logging, or notifying external systems.
For details, see cancel listeners.
Helm chart deployment
Helm v4 required
Camunda 8.10 (chart 15.x) supports the Helm CLI v4 only. Earlier Camunda versions are the last to support the Helm v3 CLI.
Switching CLIs does not require a release-state migration; Helm is client-side only. Before you run helm upgrade to 8.10, install the Helm v4 CLI.
Host network support for Orchestration Cluster pods
The 8.10 Helm chart adds orchestration.hostNetwork (default: false), which lets Orchestration Cluster pods share the host node's network namespace. This is useful in bare-metal or restricted network environments where pods must be reachable directly via the node IP rather than a cluster overlay network.
When orchestration.hostNetwork is set to true and orchestration.dnsPolicy is not set, the chart automatically uses dnsPolicy: ClusterFirstWithHostNet to preserve in-cluster DNS resolution. You can override this by setting orchestration.dnsPolicy explicitly.
orchestration:
hostNetwork: true
For details, see configure pod networking.