For the complete documentation index, see llms.txt.
Skip to main content
Version: 8.10 (unreleased)

8.10 Release notes

Release notes for new features included in the 8.10 minor release, including alpha feature releases.

Minor release dateScheduled end of maintenanceChangelog(s)Upgrade guides
13 October 202611 April 2028Patch Releases and Changelogs8.10 upgrade guides
8.10 resources
  • 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-alpha2​

Release dateChangelog(s)Blog
09 June 2026-

Agentic orchestration​

Skills repository for pro-code AI enablement​

AI agentsAgentic orchestrationEarly access

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​

AI agentsAgentic orchestration

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.properties or Spring application properties depending on the test execution context.

Processes MCP Server​

Orchestration Cluster

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.

Camunda 8 Run

FEEL evaluation with process instance key​

Orchestration Cluster API

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:EVALUATE plus PROCESS_DEFINITION:READ_PROCESS_INSTANCE on the underlying process definition.
  • Requires exactly one of processInstanceKey or elementInstanceKey (mutually exclusive); sending both returns 400 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​

Orchestration Cluster API

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

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.

Optimize​

Scope-aware variable export configuration for Optimize​

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, taskContextDisplayName or specific local audit variables) without exposing all locals.

8.10.0-alpha1​

Release dateChangelog(s)Blog
13 May 2026-

Agentic orchestration​

AI Agent connector: Conversation storage SPI redesign​

AI agentsAgentic orchestrationConnectors

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​

AI agentsAgentic orchestrationSaaS

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​

Self-ManagedSaaSWeb ModelerDesktop Modeler

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​

AI agentsAgentic orchestration

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​

SaaSCamunda Hub

Camunda Hub and Accounts now support the 2025 enterprise license model.

  • A new licensing_model attribute on OrganizationMetaData identifies 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 ExternalOnboardingRouter accepts an optional licensing model parameter (defaulting to 2025 if not provided).

Cluster version selection for SaaS orchestration clusters​

SaaSCamunda HubOrchestration Cluster

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​

Self-ManagedSaaSIDP

Camunda IDP now supports ABBYY as a document extraction provider.

Modeler​

Support for configurable headers for execution listeners​

Self-ManagedSaaSWeb ModelerDesktop Modeler

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​

Self-ManagedSaaSIntegrations

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​

SaaSOperate

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​

Self-ManagedSaaSJava clientSpring SDK

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/credentials on first use. In hardened container environments — non-root users (Kubernetes securityContext.runAsUser, OpenShift), read-only root filesystems, immutable images — this raised AccessDeniedException/IOException at 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 (or ZEEBE_CLIENT_CONFIG_PATH for 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​

Self-ManagedSaaSOrchestration Cluster

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 chartsSelf-Managed

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.