@bpmnkit/camunda-docspack 0.0.0

package/.llms/chunks/components.concepts.access-control.authorizations.security-considerations-authorization-disabled-and-secret-resolution.md

@@ -0,0 +1,6 @@
+# Orchestration Cluster authorization — Security considerations — Authorization disabled and secret resolution
+
+When authorization is disabled (see [Behavior when authorization is disabled](#behavior-when-authorization-is-disabled)), `POST /v2/secrets/resolve` does not enforce `SECRET:REVEAL`, and `POST /v2/secrets/list` does not enforce `SECRET:READ`. Resolve returns values for references the store resolves; list returns the matching references.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/authorizations

package/.llms/chunks/components.concepts.access-control.authorizations.security-considerations-create-permission-for-the-resource-deployment.md

@@ -0,0 +1,8 @@
+# Orchestration Cluster authorization — Security considerations — `CREATE` permission for the Resource (deployment)
+
+Granting `CREATE` permission on the **Resource** is equivalent to allowing remote code execution. When a user deploys a BPMN model, it can contain executable code in script tasks, service tasks, or listeners that will be run by the process engine.
+
+Only grant this permission to users and clients who are fully trusted to deploy and execute code in your environment.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/authorizations

package/.llms/chunks/components.concepts.access-control.authorizations.security-considerations-create-update-permissions-for-the-user.md

@@ -0,0 +1,8 @@
+# Orchestration Cluster authorization — Security considerations — `CREATE`/`UPDATE` permissions for the User
+
+The `CREATE` and `UPDATE` permissions for the **User** resource are highly sensitive. When a user's password is set or changed via Admin, there are no security controls enforced, such as password complexity policies.
+
+This permission should only be assigned to trusted administrators.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/authorizations

package/.llms/chunks/components.concepts.access-control.authorizations.security-considerations-no-validation-of-owner-and-resource-ids.md

@@ -0,0 +1,12 @@
+# Orchestration Cluster authorization — Security considerations — No validation of owner and resource IDs
+
+When you create an authorization, the Orchestration Cluster validates the owner depending on the `ownerType`. For `USER`, `ROLE`, `GROUP`, and `MAPPING_RULE`, the owner must exist in Admin. For `CLIENT`, the owner is not validated.
+
+The Orchestration Cluster does not validate whether the resource exists when creating an authorization.
+
+- This behavior lets you create authorizations for entities outside of the system (for example OIDC users) or for entities that will be created in the future (for example creating process definition authorizations before the process is deployed).
+
+- However, you should keep this in mind when setting up new users, groups, roles, and so on, and verify that the ID of the new entity does not accidentally match an existing authorization.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/authorizations

package/.llms/chunks/components.concepts.access-control.authorizations.security-considerations-process-level-vs.-task-level-task-permissions.md

@@ -0,0 +1,14 @@
+# Orchestration Cluster authorization — Security considerations — Process-level vs. task-level task permissions
+
+When configuring access to user tasks, keep the following in mind:
+
+- Granting `READ_USER_TASK` or `UPDATE_USER_TASK` on `Process Definition` gives broad access to all user tasks for that process definition.
+- These process‑level permissions override task‑level checks: if a user has the required process‑level permission, the engine does not evaluate `User Task` authorizations for the same operation.
+
+For most scenarios:
+
+- Assign process‑level task permissions only to trusted roles such as task managers or administrators.
+- Use `User Task` property‑based authorizations (and the default Task Worker role) to limit regular task workers to tasks where they are assignee, candidate user, or in a candidate group.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/authorizations

package/.llms/chunks/components.concepts.access-control.authorizations.security-considerations-reveal-permission-for-the-secret.md

@@ -0,0 +1,10 @@
+# Orchestration Cluster authorization — Security considerations — `REVEAL` permission for the Secret
+
+`READ` and `REVEAL` on the `SECRET` resource are not interchangeable. `READ` lets a caller see that a secret reference exists, for example, in a `POST /v2/secrets/list` response. `REVEAL` lets a caller resolve a reference to its actual value.
+
+`REVEAL` is never implied by `READ`, and it is never granted automatically alongside it. In particular, a blanket "`READ` for all resources" grant, like the built-in `readonly-admin` role uses, does not extend to `SECRET:REVEAL`. Of the built-in roles, only `admin` is granted `SECRET:REVEAL` by default; see [Default roles](#default-roles).
+
+Because `REVEAL` exposes secret values, grant it only to trusted users and clients.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/authorizations

package/.llms/chunks/components.concepts.access-control.authorizations.security-considerations-system-access-permissions.md

@@ -0,0 +1,16 @@
+# Orchestration Cluster authorization — Security considerations — System access permissions
+
+Permissions that control system access are particularly security-sensitive.
+This includes CRUD operations to the following resources:
+
+- System
+- User
+- Group
+- Role
+- Mapping rule
+- Tenant
+
+These permissions should be strictly limited to trusted system administrators who are responsible for managing user access control.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/authorizations

package/.llms/chunks/components.concepts.access-control.authorizations.security-considerations.md

@@ -0,0 +1,6 @@
+# Orchestration Cluster authorization — Security considerations
+
+Certain permissions grant powerful capabilities and should be assigned with caution. It is critical to ensure that only trusted users and clients are granted these permissions to maintain the security and integrity of your system.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/authorizations

package/.llms/chunks/components.concepts.access-control.connect-to-identity-provider.md

@@ -0,0 +1,28 @@
+# Connect to an Identity Provider
+
+Learn how to connect Camunda 8 components to an external Identity Provider (IdP) for authentication and user management.
+
+Integrate with an external identity provider (IdP) for single sign-on (SSO), centralized user management, and secure authentication.
+
+
+## About IdP integration
+
+Connecting Camunda 8 to an external IdP allows you to:
+
+- Use enterprise authentication (for example, Microsoft EntraID, Okta, Keycloak, Auth0).
+- Centrally manage users in your IdP.
+- Enable SSO for Camunda components.
+- Enforce organization-wide security policies.
+
+
+## Self-Managed
+
+Self-Managed deployments only support external IdP integration using **OpenID Connect (OIDC)** (for example, Keycloak, Auth0, Okta, EntraID via OIDC).
+
+You can integrate an IdP with both Admin (for the Orchestration Cluster) and Management Identity (for Camunda Hub and Optimize).
+
+- [Connect Orchestration Cluster Admin to an identity provider](https://docs.camunda.io/docs/next/self-managed/components/orchestration-cluster/admin/connect-external-identity-provider)
+- [Connect Management Identity to an identity provider](https://docs.camunda.io/docs/next/self-managed/components/management-identity/configuration/connect-to-an-oidc-provider)
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/connect-to-identity-provider

package/.llms/chunks/components.concepts.access-control.connect-to-identity-provider.saas.md

@@ -0,0 +1,8 @@
+# Connect to an Identity Provider — SaaS
+
+Camunda 8 SaaS currently only supports external IdP integration using **SAML** or **Azure Active Directory (EntraID)**.
+
+- [Connect to an identity provider](https://docs.camunda.io/docs/next/components/hub/organization/manage-organization-settings/external-sso)
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/connect-to-identity-provider

package/.llms/chunks/components.concepts.access-control.mapping-rules.how-to-use-mapping-rules.md

@@ -0,0 +1,46 @@
+# Mapping rules — How to use mapping rules
+
+**Info**
+To use mapping rules, you must be familiar with the structure of the JWT access tokens that your OIDC provider issues to clients.
+
+A mapping rule has the following properties:
+
+- Claim name: The name of a (nested) claim or a [JSONPath expression](https://www.rfc-editor.org/rfc/rfc9535).
+- Claim value: The expected value of the claim. The mapping rule takes effect only if this value is present in a JWT access token.
+
+Using a mapping rule is a two-step process:
+
+1. _Create the mapping rule_ – Define how Camunda identifies a match between a JWT claim and the rule.
+2. _Assign the mapping rule_ – Apply it to a group, role, authorization, or tenant.
+
+Assume the following payload of an access token issued by your Identity Provider (IdP):
+
+```json
+{
+  "sub": "1234567890",
+  "name": "John Doe",
+  "isAdmin": true,
+  "orggroups": ["acct", "finance"],
+  "iat": 1516239022
+}
+```
+
+To make any user a member of the `admin` role when their `isAdmin` claim is set to `true`, first define a mapping rule as follows:
+
+- Claim name: `isAdmin`
+- Claim value: `true`
+
+Then, assign the mapping rule to the `admin` role.
+
+To make any member of the organizational group `acct` a member of the Orchestration Cluster group `accounting`, define a mapping rule as follows:
+
+- Claim name: `orggroups`
+- Claim value: `acct`
+
+Then, assign the mapping rule to the `accounting` group.
+
+**Note**
+In this case, the mapping rule matches against an array of objects. Depending on the JWT structure, a claim value is matched using `equals` or `in` semantics.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/mapping-rules

package/.llms/chunks/components.concepts.access-control.mapping-rules.md

@@ -0,0 +1,20 @@
+# Mapping rules
+
+Map authentication entities from your Identity Provider (IdP) to Camunda-specific entities using mapping rules.
+
+Mapping rules are used to dynamically manage access control by [connecting your Identity Provider](https://docs.camunda.io/docs/next/components/concepts/access-control/connect-to-identity-provider) and mapping claims from a JWT access token to [Admin](https://docs.camunda.io/docs/next/components/admin/admin-introduction) entities in Camunda 8.
+
+
+## Mapping rules in SaaS and Self-Managed
+
+In Camunda 8 SaaS, mapping rules are not supported.
+
+In Camunda 8 Self-Managed, configure mapping rules in the following components:
+
+- Orchestration Cluster Admin: Manage permissions within an [orchestration cluster](https://docs.camunda.io/docs/next/components/orchestration-cluster). Use mapping rules to assign users to [user groups](https://docs.camunda.io/docs/next/components/admin/group) and [roles](https://docs.camunda.io/docs/next/components/admin/role), grant [authorizations](https://docs.camunda.io/docs/next/components/admin/authorization), and associate them with specific [tenants](https://docs.camunda.io/docs/next/components/admin/tenant).
+- Mapping rules are available for Orchestration Cluster Admin only when using [OIDC-based authentication](https://docs.camunda.io/docs/next/self-managed/components/orchestration-cluster/admin/connect-external-identity-provider). They do not apply to other authentication methods, such as Basic authentication.
+
+- Management Identity: Manage access to components like [Camunda Hub](https://docs.camunda.io/docs/next/self-managed/components/hub/index) and [Optimize](https://docs.camunda.io/docs/next/self-managed/components/optimize/overview). Mapping rules in [Management Identity](https://docs.camunda.io/docs/next/self-managed/components/management-identity/overview) assign users to roles and tenants, granting access to those components. To learn more, see the [guide on managing mapping rules in Management Identity](https://docs.camunda.io/docs/next/self-managed/components/management-identity/mapping-rules).
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/mapping-rules

package/.llms/chunks/components.concepts.access-control.mapping-rules.references.md

@@ -0,0 +1,10 @@
+# Mapping rules — References
+
+For more details on configuring mapping rules in a Self-Managed environment, see:
+
+- [Manage mapping rules in Orchestration Cluster Admin](https://docs.camunda.io/docs/next/components/admin/mapping-rules)
+- [Manage mapping rules in Management Identity](https://docs.camunda.io/docs/next/self-managed/components/management-identity/mapping-rules)
+- [Manage mapping rules via API](https://docs.camunda.io/docs/next/apis-tools/orchestration-cluster-api-rest/specifications/create-mapping-rule.api)
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/access-control/mapping-rules

package/.llms/chunks/components.concepts.batch-operations.authorization.md

@@ -0,0 +1,18 @@
+# Batch operations — Authorization
+
+When executing a batch operation, there are two sets of permissions involved:
+
+- Batch operation permissions.
+- Item-level, or process definition, permissions.
+
+To create a batch operation, you always need both the permission to create batch operations as well as permissions to read process instances and execute specific operations on each targeted process instance.
+
+To suspend, resume, or cancel an operation, you only need the relevant batch operation permissions.
+
+The system stores authorization claims with the batch operation and uses them throughout its lifecycle.
+
+**Info**
+Read more about [authorizations](https://docs.camunda.io/docs/next/components/concepts/access-control/authorizations) and [how to create them in the Admin UI](https://docs.camunda.io/docs/next/components/admin/authorization).
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/batch-operations

package/.llms/chunks/components.concepts.batch-operations.md

@@ -0,0 +1,25 @@
+# Batch operations
+
+Get an overview of batch operations in Camunda 8.
+
+A high-level overview of batch operations in Camunda 8.
+
+
+## About batch operations
+
+If a single process instance encounters an incident, or you need to update the instance for any other reason, you can perform an instance operation. However, if you need to perform the same operation on multiple instances, a batch operation:
+
+- Optimizes the performance of operations that need to be performed across many process instances.
+- Provides insights into the progress of the operation across all affected instances.
+- Gives you control over operation execution, with the ability to suspend, resume, and cancel operations.
+
+A **batch operation** is an operation on a selection, or batch, of process instances. Instead of manually operating on each instance, you can specify filter criteria and automatically identify and process matching instances across your cluster in parallel. The individual operation in the batch applied to a process instance is called a [**batch item**](https://docs.camunda.io/docs/next/components/zeebe/technical-concepts/batch-operations#batch-operation-components).
+
+Example use cases include:
+
+- Many process instances have encountered a critical bug.
+- You need to skip an activity across multiple instances.
+- There was in issue when executing a process that corrupted many or all instances of that process.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/batch-operations

package/.llms/chunks/components.concepts.batch-operations.next-steps.md

@@ -0,0 +1,15 @@
+# Batch operations — Next steps
+
+- [Learn how batch operations work](https://docs.camunda.io/docs/next/components/zeebe/technical-concepts/batch-operations).
+- [Use batch operations in the Camunda 8 web interface](https://docs.camunda.io/docs/next/components/operate/userguide/selections-operations).
+- Use the batch operations APIs:
+  - [Search batch operations](https://docs.camunda.io/docs/next/apis-tools/orchestration-cluster-api-rest/specifications/search-batch-operations.api).
+  - [Cancel process instances (batch)](https://docs.camunda.io/docs/next/apis-tools/orchestration-cluster-api-rest/specifications/cancel-process-instances-batch-operation.api).
+  - [Resolve related incidents (batch)](https://docs.camunda.io/docs/next/apis-tools/orchestration-cluster-api-rest/specifications/resolve-incidents-batch-operation.api).
+  - [Migrate process instances (batch)](https://docs.camunda.io/docs/next/apis-tools/orchestration-cluster-api-rest/specifications/migrate-process-instances-batch-operation.api).
+  - [Modify process instances (batch)](https://docs.camunda.io/docs/next/apis-tools/orchestration-cluster-api-rest/specifications/modify-process-instances-batch-operation.api).
+  - [Delete process instances (batch)](https://docs.camunda.io/docs/next/apis-tools/orchestration-cluster-api-rest/specifications/delete-process-instances-batch-operation.api).
+  - [Delete decision instances (batch)](https://docs.camunda.io/docs/next/apis-tools/orchestration-cluster-api-rest/specifications/delete-decision-instances-batch-operation.api).
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/batch-operations

package/.llms/chunks/components.concepts.batch-operations.states.md

@@ -0,0 +1,19 @@
+# Batch operations — States
+
+A batch operation can have one of the following statuses:
+
+| Type                | Description                                                                                                           |
+| ------------------- | --------------------------------------------------------------------------------------------------------------------- |
+| Created             | The batch operation was created, but the filter hasn't been used yet to determine the affected process instances.     |
+| Active              | The batch operation is actively being processed.                                                                      |
+| Completed           | All items in the batch operation were processed, regardless of whether the individual operations succeeded or failed. |
+| Partially completed | The batch operation successfully processed at least one partition and failed to process at least one partition.       |
+| Suspended           | The batch operation was temporarily stopped. Suspended batch operations can be resumed.                               |
+| Canceled            | The batch operation was permanently stopped. Canceled batch operations can't be resumed.                              |
+| Failed              | The batch operation failed on all partitions.                                                                         |
+
+**Info**
+Learn more about batch partitions in our [implementation overview](https://docs.camunda.io/docs/next/components/zeebe/technical-concepts/batch-operations).
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/batch-operations

package/.llms/chunks/components.concepts.batch-operations.types.md

@@ -0,0 +1,20 @@
+# Batch operations — Types
+
+Here are the types of available batch operations:
+
+| Type                      | Description                                                                                        |
+| ------------------------- | -------------------------------------------------------------------------------------------------- |
+| Resolve incidents         | Resolves the [incidents](https://docs.camunda.io/docs/next/components/concepts/incidents) associated with a batch of process instances.             |
+| Modify process instances  | [Moves](https://docs.camunda.io/docs/next/components/concepts/process-instance-modification) a batch of process instances from one node to another. |
+| Migrate process instances | [Migrates](https://docs.camunda.io/docs/next/components/concepts/process-instance-migration) a batch of process instances to a new process version. |
+| Cancel process instances  | Cancels a batch of process instances.                                                              |
+| Delete process instances  | [Deletes](https://docs.camunda.io/docs/next/components/concepts/process-instance-deletion) a batch of process instances.                            |
+| Delete decision instances | [Deletes](https://docs.camunda.io/docs/next/components/concepts/decision-instance-deletion) a batch of decision instances.                          |
+
+Furthermore, depending on the status of the batch operation, you may be able to suspend, cancel, or resume the operation.
+
+**Warning**
+Canceling a batch operation does not rollback any changes that have already been produced.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/batch-operations

package/.llms/chunks/components.concepts.bpmn-dmn-feel.feel-expressions.md

@@ -0,0 +1,8 @@
+# BPMN, DMN, and FEEL — FEEL expressions
+
+FEEL is designed to write expressions in a way that is easily understood by both business professionals and developers. In Camunda, FEEL is used to define expressions in the context of BPMN diagrams, DMN diagrams, and Forms. FEEL is specified in the DMN specification of the Object Management Group (OMG).
+
+What is FEEL?
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/bpmn-dmn-feel

package/.llms/chunks/components.concepts.bpmn-dmn-feel.md

@@ -0,0 +1,22 @@
+# BPMN, DMN, and FEEL
+
+Camunda overview
+
+Use Business Process Model and Notation (BPMN), Decision Model and Notation (DMN), and Friendly Enough Expression Language (FEEL) in your process diagrams.
+
+
+## BPMN
+
+BPMN was developed as a graphical notation to represent complex processes. It is maintained by the non-profit The Object Management Group (OMG) and employed by numerous organizations globally. The visual nature of BPMN enables greater collaboration between different teams, particularly within Modeler.
+
+BPMN in Modeler
+
+
+## DMN
+
+DMN is a modeling approach owned by an institution called the Object Management Group (OMG), which also operates worldwide standards for BPMN. In DMN, decisions are modeled and executed using a language both business analysts and developers can understand. Model a set of rules within a table, and this will yield a decision to rapidly execute a process using a decision engine like Camunda.
+
+DMN in Modeler
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/bpmn-dmn-feel

package/.llms/chunks/components.concepts.clusters.cluster-size.md

@@ -0,0 +1,19 @@
+# Clusters — Cluster size
+
+The cluster size defines the cluster performance and capacity.
+
+After you have chosen your cluster type, choose the cluster size that best meets your cluster environment requirements.
+
+To learn more about choosing your cluster size, see [sizing your environment](https://docs.camunda.io/docs/next/components/best-practices/architecture/sizing-your-environment#sizing-your-runtime-environment).
+
+- You can choose from four cluster sizes: 1x, 2x, 3x, and 4x.
+- Larger cluster sizes include increased performance and capacity, allowing you to serve more workload.
+- Increased usage such as higher throughput or longer data retention requires a larger cluster size.
+- Each size increase uses one of your available cluster reservations. For example, purchasing two HWP advanced reservations for your production cluster allows you to configure two clusters of size 1x, or one cluster of size 2x.
+- You can change the cluster size at any time. See [resize a cluster](https://docs.camunda.io/docs/next/components/hub/organization/manage-clusters/manage-cluster#resize-a-cluster).
+
+**Note**
+To increase the cluster size beyond the maximum 4x size, [reach out to Camunda](https://camunda.com/contact-us/). This requires custom sizing and pricing.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/clusters

package/.llms/chunks/components.concepts.clusters.free-trial-clusters.md

@@ -0,0 +1,25 @@
+# Clusters — Free Trial clusters
+
+Free Trial clusters have the same functionality as a production cluster, but are of a Basic type and 1x size, and only available during your trial period. You cannot convert a Free Trial cluster to a different type of cluster.
+
+Once you sign up for a Free Trial, you are able to create one production cluster for the duration of your trial.
+
+When your Free Trial plan expires, you are automatically transferred to the Free plan. This plan allows you to model BPMN and DMN collaboratively, but does not support execution of your models. Any cluster created during your trial is deleted, and you cannot create new clusters.
+
+### Auto-pause
+
+Free Trial clusters are automatically paused after a period of inactivity. Auto-pause occurs regardless of cluster usage.
+
+You can resume a paused cluster at any time, which typically takes five to ten minutes to complete. See [resume a cluster](https://docs.camunda.io/docs/next/components/hub/organization/manage-clusters/manage-cluster#resume-a-cluster).
+
+- Clusters tagged as `dev` (or untagged) auto-pause eight hours after the cluster is created or resumed from a paused state.
+- Clusters auto-pause if there is no cluster activity for 48 hours.
+- Cluster disk space is cleared when a trial cluster is paused.
+  - You will need to redeploy processes to the cluster once it is resumed from a paused state.
+  - Cluster configuration settings (for example, API Clients, connector secrets, and IP allowlists) are saved so you can easily resume a cluster.
+
+**Tip**
+To prevent auto-pause, [upgrade your Free Trial plan](https://camunda.com/pricing/) to an Enterprise plan.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/clusters

package/.llms/chunks/components.concepts.clusters.md

@@ -0,0 +1,35 @@
+# Clusters
+
+Learn more about the clusters available in your Camunda 8 plan.
+
+A [cluster](https://docs.camunda.io/docs/next/components/hub/organization/manage-clusters/create-cluster) is a provided group of production-ready nodes that run Camunda 8.
+
+When [creating a cluster in SaaS](https://docs.camunda.io/docs/next/components/hub/organization/manage-clusters/create-cluster), you can choose the cluster **type** and **size** to meet your organization's availability and scalability needs, and to provide control over cluster performance, uptime, and disaster recovery guarantees.
+
+
+## Cluster type
+
+The cluster type defines the level of availability and uptime for the cluster.
+
+You can choose from three different cluster types:
+
+- **Basic**: A cluster for non-production use, including experimentation, early development, and basic use cases that do not require a guaranteed high uptime.
+- **Standard**: A production-ready cluster with guaranteed higher uptime.
+- **Advanced**: A production-ready cluster with guaranteed minimal disruption and the highest uptime.
+
+### Cluster availability and uptime
+
+| Type                                                                        | Basic                                                                                  | Standard                                                  | Advanced                                                                              |
+| :-------------------------------------------------------------------------- | :------------------------------------------------------------------------------------- | :-------------------------------------------------------- | :------------------------------------------------------------------------------------ |
+| Usage                                                                       | Non-production use, including experimentation, early development, and basic use cases. | Production-ready use cases with guaranteed higher uptime. | Production-ready use cases with guaranteed minimal disruption and the highest uptime. |
+| Uptime Percentage (Orchestration Cluster\*)           | 99%                                                                                    | 99.5%                                                     | 99.9%                                                                                 |
+| RTO/RPO\*\*(Orchestration Cluster\*) | RTO: 8 hoursRPO: 24 hours                                                         | RTO: 2 hoursRPO: 4 hours                             | RTO: < 1 hourRPO: < 1 hour                                                       |
+
+* Orchestration Cluster means the components critical for automating processes and decisions, such as Zeebe, Operate, Tasklist, Optimize, and connectors.
+**  RTO (Recovery Time Objective) means the maximum allowable time that a system or application can be down after a failure or disaster before it must be restored. It defines the target time to get the system back up and running. RPO (Recovery Point Objective) means the maximum acceptable amount of data loss measured in time. It indicates the point in time to which data must be restored to resume normal operations after a failure. It defines how much data you can afford to lose. The RTO/RPO figures shown in the table are provided on a best-effort basis and are not guaranteed.
+
+**Info**
+See [Camunda Enterprise General Terms](https://legal.camunda.com/licensing-and-other-legal-terms#camunda-enterprise-general-terms) for term definitions for **Monthly Uptime Percentage** and **Downtime**.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/clusters

package/.llms/chunks/components.concepts.concepts-overview.camunda-8-use-cases.md

@@ -0,0 +1,45 @@
+# Introduction to Camunda 8 — Camunda 8 use cases
+
+With Camunda 8, you can model, execute, and operate complex business processes from end to end, combining systems, human work, and AI agents.
+
+Most real-world automation is distributed. A single business outcome (for example, customer onboarding, claims handling, or order fulfillment) often requires many independently deployed services and external systems. That makes it hard to keep the overall process visible, understand where work is waiting, and recover cleanly when something fails. Camunda provides a process orchestration layer that coordinates these endpoints without forcing you into a tightly-coupled architecture.
+
+### Orchestrate distributed systems
+
+Define process and decision logic using BPMN and DMN, then run it on a stateful, event-driven workflow engine designed for long-running, high-volume execution. This gives teams a consistent way to:
+
+- Trigger work and correlate events across services.
+- Handle retries and compensation when a step fails.
+- Troubleshoot incidents across the full business process, not just within a single service.
+
+[Learn about processes](https://docs.camunda.io/docs/next/components/concepts/processes)
+
+### Coordinate human work
+
+Many processes also require human input, either as a normal step (for example, review or approval) or as a fallback when automation can't proceed. With Camunda, you can model human tasks alongside automated steps, then assign, track, and escalate work so the process keeps moving.
+
+For example, if customer onboarding is blocked waiting for a verification task, the process can route to the right person, enforce due dates, and make the delay visible in operations tooling.
+
+[Learn about Tasklist](https://docs.camunda.io/docs/next/components/tasklist/introduction-to-tasklist)
+
+### Orchestrate AI agents
+
+Not every step in a process can be fully predetermined. When the right action depends on judgment, such as interpreting a document, deciding which check to run next, or triaging an exception, you can hand that step to an AI agent, then return to the fixed steps that follow. With Camunda, you can:
+
+- Treat agents as process endpoints, just like a microservice or API call, and orchestrate them alongside deterministic steps and human checkpoints.
+- Build agents directly in Camunda by modeling agent behavior such as planning loops, tool use, and reflection, including short-term and long-term memory and retrieval-augmented generation (RAG).
+- Apply the same guardrails your process requires, such as role-based access control, compliance boundaries, incident recovery, and audit trails, to agent-driven steps.
+
+Because agents run inside the same governed process, their actions are observable and auditable by default.
+
+[Learn about agentic orchestration](https://docs.camunda.io/docs/next/components/agentic-orchestration/agentic-orchestration-overview)
+
+### Common use cases
+
+- Orchestrating microservices across complex integrations.
+- Modernizing long-running processes that cross legacy systems.
+- Coordinating human work with automation.
+- Running AI-assisted steps, such as document interpretation or decision support, inside governed, end-to-end processes.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/concepts-overview

package/.llms/chunks/components.concepts.concepts-overview.how-does-camunda-8-compare-to-other-solutions.md

@@ -0,0 +1,24 @@
+# Introduction to Camunda 8 — How does Camunda 8 compare to other solutions?
+
+### Composability
+
+Camunda's integrated yet flexible architecture facilitates best-of-breed technology and reuse. Combine Camunda task automation with other tools and custom code for maximum flexibility. Choose SaaS or Self-Managed, and use your preferred cloud, Kubernetes, and identity provider.
+
+### Open architecture
+
+Integrate with a variety of applications, systems, and services to scale your architecture. Camunda works with your preferred source control, CI/CD pipelines, and programming languages, while well-documented APIs, SDKs, and polyglot clients enable easy integration and customization.
+
+### IT and business collaboration
+
+IT and business stakeholders build and test processes in a shared modeling environment using the shared languages of BPMN and DMN. Reusable process assets such as connectors and AI agents make it easy to onboard new teams.
+
+### Scalability
+
+Event streaming avoids database bottlenecks and can scale process throughput in a highly effective way. Camunda's distributed architecture ensures continuity in the case of hardware or network failure and supports replication across global data centers for high availability.
+
+### Intelligence
+
+Rather than relying on prompt instructions alone to keep agents in bounds, Camunda enforces guardrails structurally, as explicit steps in the process, so agent behavior stays governed as autonomy increases. Camunda is model- and framework-agnostic: bring your own LLM, and orchestrate agents built with other frameworks alongside agents modeled natively in BPMN, all within the same auditable process.
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/concepts-overview

package/.llms/chunks/components.concepts.concepts-overview.md

@@ -0,0 +1,45 @@
+# Introduction to Camunda 8
+
+Learn how Camunda 8 components work together to orchestrate and automate business processes, including the platform architecture and storage roles.
+
+Use [Camunda 8](https://camunda.io) to orchestrate and automate complex business processes that include people, AI agents, systems, and devices.
+
+
+## About Camunda 8
+
+You can deploy Camunda 8 in two ways:
+
+- **Camunda 8 SaaS**: A fully managed cloud service for rapid deployment and minimal operational overhead.
+- **Camunda 8 Self-Managed**: A self-hosted solution for organizations requiring full control over their infrastructure.
+
+Camunda 8 combines powerful execution engines for BPMN processes and DMN decisions with tools for collaborative modeling, operations, and analytics. Camunda 8 [components](https://docs.camunda.io/docs/next/components/components-overview) work together to form the complete Camunda 8 experience, allowing you to design, automate, and improve your business processes.
+
+Camunda 8 separates runtime execution data from analytical and operational data by using distinct storage roles.
+
+### Storage architecture
+
+In the diagram above, storage systems appear in two distinct roles:
+
+- **Primary storage**: The authoritative store for runtime execution state used by the [Orchestration Cluster](https://docs.camunda.io/docs/next/reference/glossary#orchestration-cluster) to execute, recover, and replicate workflows. This includes partition logs and snapshots and is tightly coupled to process execution. See [primary storage](https://docs.camunda.io/docs/next/reference/glossary#primary-storage).
+- **Secondary storage**: Systems used for indexing, search, analytics, operational views, and long-term retention. Data is populated from primary storage and optimized for querying rather than execution. See [secondary storage](https://docs.camunda.io/docs/next/reference/glossary#secondary-storage).
+
+#### Secondary storage implementations
+
+Camunda 8 supports multiple secondary storage backends, depending on the deployment model and configuration:
+
+- **Embedded H2**: A bundled secondary storage option for local development and lightweight setups. See [H2](https://docs.camunda.io/docs/next/reference/glossary#h2).
+- **External RDBMS**: A user-managed relational database used as secondary storage in Self-Managed deployments. See [RDBMS](https://docs.camunda.io/docs/next/reference/glossary#rdbms).
+- **Elasticsearch / OpenSearch**: Search-optimized backends commonly used for analytics and operational visibility. See [Elasticsearch/OpenSearch](https://docs.camunda.io/docs/next/reference/glossary#elasticsearchopensearch).
+
+For deployment and configuration guidance, see the Self-Managed documentation:
+
+- [About Self-Managed](https://docs.camunda.io/docs/next/self-managed/about-self-managed)
+- [Helm quick install](https://docs.camunda.io/docs/next/self-managed/deployment/helm/install/quick-install)
+
+**Info**
+
+- Want to migrate your Camunda 7 process solutions to run on Camunda 8? See our [Camunda 7 migration guide](https://docs.camunda.io/docs/next/guides/migrating-from-camunda-7/index).
+- Deployment guides for Camunda 8 components are available in the [Self-Managed section](https://docs.camunda.io/docs/next/self-managed/about-self-managed).
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/concepts-overview

package/.llms/chunks/components.concepts.concepts-overview.next-steps.md

@@ -0,0 +1,11 @@
+# Introduction to Camunda 8 — Next steps
+
+- To request information about Camunda 8 performance and benchmarking, refer to our [Contact](https://docs.camunda.io/docs/next/reference/contact) page.
+- [Introduction to Camunda 8](https://docs.camunda.io/docs/next/guides/introduction-to-camunda-8)
+- [Create a Camunda 8 account](https://docs.camunda.io/docs/next/components/hub/organization/manage-organization-settings/manage-plan/create-account)
+- [Migrate from Camunda 7 to Camunda 8](https://docs.camunda.io/docs/next/guides/migrating-from-camunda-7/index)
+- [Automate a process using BPMN](https://docs.camunda.io/docs/next/components/modeler/bpmn/automating-a-process-using-bpmn)
+- [Build your first AI agent](https://docs.camunda.io/docs/next/guides/getting-started-agentic-orchestration)
+
+---
+Source: https://docs.camunda.io/docs/next/components/concepts/concepts-overview