Camunda

Zeebe: the orchestration engine built for enterprise scale.

The distributed engine at the heart of Camunda. Built for the long-running, mission-critical processes your business depends on, and ready for the durable multi-agent coordination that comes next.

Built for the work your business is measured on

The processes your business is measured on are rarely short. Claims span weeks. Onboarding stretches across systems. Lending and underwriting run for days, sometimes months.

Customer commitments stay on track

Long-running cases hold their state across days, weeks, or months without dropping work or stalling.

Operations never go dark

If a node fails, another takes over automatically. No data loss, no downtime, no late-night incident calls.

Improvements ship without stopping the business

Deploy new process versions while current ones keep running. Migrate live cases at runtime.

Distributed by design

Most workflow engines route every transaction through a central database. That database becomes the bottleneck and the failure mode. Zeebe takes a different approach.

Horizontal scalability

No central database to choke on. Add nodes to add throughput.

Self-healing brokers

Peer-to-peer broker topology with no single point of failure.

Continuous version migration

Deploy new versions while current ones run. Upgrade continuously without ever stopping operations.

Every team gets the isolation its use case and policy require

Camunda offers three tenancy models on one platform and one set of tooling. Onboard teams onto infrastructure you already operate, and reserve dedicated clusters for the workloads whose policies or regulatory requirements call for them. Models are complementary and can be layered to meet your needs.

SaaS and Self-Managed

Logical tenants

Bring a new team, brand, or product line onto a cluster you already run, at the lowest operating cost. Tenants share the cluster and its data store, with every record stamped by tenant ID and access authorized per tenant.

Best for: Product lines, brands, and partner-facing applications that share a process

Example: A software provider runs the same onboarding process for every customer, with each customer kept in its own tenant.

Strong isolation · New in 8.10 · Self-Managed (SaaS on roadmap)

Physical tenants

Give each internal domain control over its environment without adding another to operate. Each tenant runs on its own engine partitions, with distinct secondary storage, identity provider, and resilience settings.

Best for: Domains with their own identity, compliance, or recovery requirements

Example: A bank runs payments and lending on one cluster, each with its own identity provider, compliance rules, and backup.

Maximum isolation · SaaS and Self-Managed

Dedicated clusters

Keep regulated or independent units fully apart, with separation you can demonstrate to regulators and auditors. Each unit runs on its own cluster, with no shared processes, storage, or networking.

Best for: Ring-fenced legal entities, data residency, sovereign units, or tenants for each stage of development

Example: A global company runs separate EU and APAC clusters so customer data stays in-region.

Lighter separationMaximum separation
Compare the three models
Logical tenantsPhysical tenantsDedicated clusters
IsolationBy tenant IDPhysical, in one clusterFull, separate clusters
Engine partitionsSharedDedicated per tenantSeparate per cluster
Secondary storage (history, search)SharedPer tenantPer cluster
IdentitySharedPer tenantPer cluster
Backup and restoreCluster-widePer tenantPer cluster
Cost profileMost efficientBalancedHighest
AvailabilitySaaS and Self-ManagedSelf-Managed (8.10), SaaS on roadmapSaaS and Self-Managed

Native support for the patterns enterprise processes actually need

Real enterprise processes are not happy paths. They compensate, escalate, branch dynamically, correlate inbound events, and recover from upstream failures.

Compensation

Roll back a transaction cleanly when downstream steps fail.

Dynamic parallel execution

Spawn branches at runtime based on real-time conditions and merge results when complete.

Message correlation

Match inbound messages from external systems to the correct in-flight process instance.

Time-based escalation

Automatically route overdue tasks to the next tier when SLAs are at risk.

Durable coordination for multi-agent processes

Agentic processes need an engine that can hold state across long-running, multi-agent work.

Zeebe natively supports both handoff and supervisor agent patterns.

No other framework provides this at enterprise scale.

Orchestration Engine FAQ

  • What is Zeebe?
    Zeebe is the distributed orchestration engine at the core of Camunda 8. It executes BPMN process models across people, systems, and AI agents, and holds each process instance’s state for as long as the work runs, from seconds to months. Its distributed design removes the central database that limits throughput in traditional workflow engines.
  • How does Zeebe scale without a central database?
    Zeebe splits process data into partitions, each replicated across brokers and processed as an event stream. Every broker keeps the state for its partitions locally, so execution never waits on a shared database. To increase throughput, you add brokers to the cluster.
  • What happens when a Zeebe node fails?
    Each partition is replicated across multiple brokers. When a broker fails, a replica that already holds the committed data takes over its partitions and processing continues. Running process instances keep their state, and no one has to restart them by hand.
  • Can multiple teams run on the same Zeebe cluster?
    Yes. Logical tenants separate teams on one cluster by tenant ID. Physical tenants give each team its own engine partitions, secondary storage, identity provider, and backup inside one cluster. For units that must stay fully independent, Camunda also supports dedicated clusters on the same platform and tooling.
  • How does Zeebe support AI agents?
    Zeebe holds durable state for agentic processes, so an agent’s work survives restarts, waits, and handoffs across long-running processes. This basically means it can wait for years until a signal, like new case information, allows it to continue further in the process. It supports both handoff and supervisor agent patterns, and it runs agents inside BPMN models alongside deterministic steps and human tasks, which keeps every agent action governed and auditable. You’re also able to have visibility over agents that are built with other frameworks but operating in a Camunda process.

Ready to get started?