Skip to content

Connect Camunda to Claude: Manage Life Cycles & Evaluate Decisions

Learn how to connect Camunda to Claude using Truto's managed MCP server. This step-by-step guide covers UI and API setup, tool calling, and workflow automation.

Sidharth Verma Sidharth Verma · · 10 min read
Connect Camunda to Claude: Manage Life Cycles & Evaluate Decisions

If your team needs to connect Camunda to Claude to automate process orchestration, resolve active incidents, or evaluate complex decision tables, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Camunda's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting Camunda to ChatGPT or explore our broader architectural overview on connecting Camunda to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling orchestration engine like Camunda 8 is an engineering challenge. You have to handle OAuth 2.0 token lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Camunda's strict, eventual-consistency state machine constraints. Every time Camunda updates an endpoint or changes how Zeebe handles deployments, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Camunda, connect it natively to Claude Desktop, and execute complex business process workflows using natural language.

The Engineering Reality of the Camunda API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Camunda's APIs is painful. Camunda is built to orchestrate long-running, distributed microservices. Its API reflects the complexity of a high-throughput, eventual-consistency system.

If you decide to build a custom Camunda MCP server, here are the specific integration challenges you will face:

Eventual Consistency and Polling Constraints Camunda 8 (Zeebe) separates command execution from state representation. When you tell the API to modify a process instance or deploy a new Business Process Model and Notation (BPMN) file, the system accepts the command but the read-state (Elasticsearch/OpenSearch) takes time to reflect it. An LLM expects synchronous results. If Claude creates a process instance and immediately tries to query its state, it will often get a 404. You have to build polling logic into your MCP server or prompt the LLM to understand that newly created data takes a few seconds to appear.

Asynchronous Batch Operations Operations like suspending, migrating, or cancelling multiple process instances are not simple HTTP DELETE or PUT requests. They are asynchronous batch operations. When you hit the camunda_process_instances_bulk_suspend endpoint, the API returns a batchOperationKey. Your integration layer must track this key, hit the /batch-operations/{batchOperationKey} endpoint to monitor progress, and report back to the LLM. An LLM cannot inherently manage this async state machine without strictly defined tools and instructions.

Complex Incident Resolution State Machines You cannot just "force resolve" a Camunda incident. Incidents represent a hard stop in the process lifecycle - usually an unhandled exception or missing payload data. To fix an incident, the LLM must first update the missing variable context via create_a_camunda_element_instance_variable, and only then call camunda_incidents_resolve. If you just hand an LLM the resolve endpoint without the variable update endpoint, it will continuously hallucinate solutions that get rejected by the Camunda broker.

Rate Limits and 429 Backoffs Camunda APIs enforce strict rate limits depending on your SaaS tier or self-hosted configuration. Truto does not retry, throttle, or apply backoff on rate limit errors. When an upstream API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. Your MCP client or agent framework is responsible for handling the retry and backoff logic.

Creating the Camunda MCP Server

Truto derives MCP tools dynamically from the integration's underlying resource definitions and documentation records. If an endpoint is documented in Truto, it becomes a callable tool. Each MCP server is scoped to a single connected instance of your Camunda account (an "integrated account").

You can create this server in two ways: via the Truto UI for rapid prototyping, or via the REST API for programmatic deployment.

Method 1: Via the Truto UI

For administrators setting up a workspace for internal agents, the UI is the fastest path.

  1. Navigate to the Integrated Accounts page in your Truto dashboard.
  2. Select your connected Camunda account.
  3. Click the MCP Servers tab.
  4. Click Create MCP Server.
  5. Select your desired configuration (Name, allowed methods like read or write, and specific tag filters if you only want to expose user tasks or incidents).
  6. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...). This URL contains a hashed cryptographic token that handles authentication automatically.

Method 2: Via the Truto API

For engineering teams embedding AI agents into their own products, you can generate MCP servers dynamically. The API validates that the integration has tools available, generates a secure token, and returns a ready-to-use URL.

Make a POST request to /integrated-account/:id/mcp:

curl -X POST https://api.truto.one/admin/integrated-account/{account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Camunda Operations Agent",
    "config": {
      "methods": ["read", "write", "custom"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

Response:

{
  "id": "mcp-7a8b9c",
  "name": "Camunda Operations Agent",
  "config": {
    "methods": ["read", "write", "custom"]
  },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/abc123def456..."
}

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you need to connect it to Claude. The process differs slightly depending on whether you are using the Claude desktop app/web UI or configuring a programmatic AI agent framework.

Method 1: Via the Claude UI

If your organization uses Claude Enterprise or Claude Desktop, you can add the server directly through the interface.

  1. Open Claude and navigate to Settings -> Integrations.
  2. Click Add MCP Server (or "Add custom connector" depending on your tier).
  3. Name the integration (e.g., "Camunda Production Server").
  4. Paste the Truto MCP server URL you generated earlier.
  5. Click Add. Claude will instantly send an initialize request, discover the Camunda tools, and make them available in the chat interface.

Method 2: Via Manual JSON Configuration

If you are running Claude Desktop locally or managing environments for developers, you can use the standard MCP configuration file (claude_desktop_config.json). Since Truto's MCP servers operate over Server-Sent Events (SSE), you will use the official @modelcontextprotocol/server-sse package to handle the transport layer.

Edit your claude_desktop_config.json file:

{
  "mcpServers": {
    "camunda_prod": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/abc123def456..."
      ]
    }
  }
}

Restart Claude Desktop. The client will establish the SSE connection and pull the dynamically generated tool schemas from Camunda.

Hero Tools for Camunda

Truto automatically maps the complex nested objects of Camunda into a flat input namespace for the LLM. Query parameters and body parameters share a single flat object, and the underlying proxy routing splits them correctly based on the JSON schemas.

Here are the highest-leverage tools available for Camunda orchestration.

Create a Process Instance

Starts an instance of a specified process. You can start it using a BPMN process ID and a specific version, or just default to the latest ACTIVE version.

Tool Name: create_a_camunda_process_instance

"Kick off a new onboarding process instance for user ID 8472. Use the latest active version of the 'employee_onboarding' BPMN definition. Pass the variables {'department': 'engineering', 'role': 'senior'}."

List All User Tasks

Searches across the cluster for user tasks based on assignee, state (CREATED, COMPLETED), or process instance. This is highly paginated and eventually consistent.

Tool Name: list_all_camunda_user_tasks

"Find all unassigned user tasks currently sitting in the 'CREATION' state that belong to the 'loan_approval_process' definition. Give me their task keys and priorities."

Complete a User Task

Completes a specific manual task and moves the process token forward. It optionally allows you to inject process variables to influence the next gateway.

Tool Name: camunda_user_tasks_complete

"Complete user task key '2251799813685250'. Set the process variable 'approval_status' to 'APPROVED' and 'reviewer_notes' to 'Looks good to go'."

List All Incidents

Queries the system for active incidents, which usually represent technical failures like missing variables, failed job workers, or unhandled BPMN errors.

Tool Name: list_all_camunda_incidents

"Check if process instance '2251799813689999' has any active incidents. If it does, tell me the incident error type and the exact error message."

Resolve an Incident

Resolves an incident, allowing the process instance to continue. Note that the underlying cause (like a missing variable) must be fixed first, or the incident will immediately recreate itself.

Tool Name: camunda_incidents_resolve

"Resolve incident '2251799813681111' now that I have manually fixed the missing customer payload."

Evaluate a Decision (DMN)

Evaluates a Decision Model and Notation (DMN) table without starting a full process instance. Ideal for isolated business rule checks.

Tool Name: camunda_decision_definitions_evaluate

"Run an evaluation against the 'credit_score_routing' decision definition using the variables {'credit_score': 720, 'income': 95000}. What is the routed outcome?"

Bulk Suspend Process Instances

Suspends multiple running process instances simultaneously via an asynchronous batch operation. Child instances are suspended independently.

Tool Name: camunda_process_instances_bulk_suspend

"Suspend all active process instances belonging to the 'legacy_payment_processor' definition. We have a database outage and need to pause the workflow until it recovers."

For the complete tool inventory, including deployment APIs, cluster topology fetching, and agent evaluations, check out the Camunda integration page.

Workflows in Action

LLMs shine when orchestrating multi-step workflows. Because Truto's tools handle the complex pagination (page.after with page.limit) and schema mappings, Claude can string together Camunda API calls to solve complex operational issues autonomously.

Workflow 1: Investigating and Resolving an Incident

Incidents in Camunda halt business processes. An LLM can act as a Level 1 support engineer, diagnosing the failure, patching the data, and unblocking the workflow.

"Process instance 2251799813685555 seems to be stuck. Check if there are any incidents. If it failed due to a missing 'account_tier' variable, update the variable to 'enterprise' on the element instance, and then resolve the incident."

  1. Claude calls list_all_camunda_incidents filtering by processInstanceKey=2251799813685555.
  2. Claude reads the response, sees an incident with errorType: EXTRACT_VALUE_ERROR pointing to a missing variable.
  3. Claude parses the elementInstanceKey from the incident data.
  4. Claude calls create_a_camunda_element_instance_variable passing the elementInstanceKey and variables: {"account_tier": "enterprise"}.
  5. Claude calls camunda_incidents_resolve using the incidentKey to unblock the flow.
sequenceDiagram
    participant User as User
    participant Claude as Claude
    participant MCP as Truto MCP
    participant Camunda as Camunda API

    User->>Claude: "Fix stuck process instance 2251..."
    Claude->>MCP: Call list_all_camunda_incidents
    MCP->>Camunda: GET /incidents?processInstanceKey=2251...
    Camunda-->>Claude: Returns incident (missing variable)
    Claude->>MCP: Call create_a_camunda_element_instance_variable
    MCP->>Camunda: POST /element-instances/{key}/variables
    Camunda-->>Claude: 204 No Content
    Claude->>MCP: Call camunda_incidents_resolve
    MCP->>Camunda: POST /incidents/{key}/resolve
    Camunda-->>User: "Variable updated and incident resolved."

Workflow 2: Business Rule Evaluation and Task Assignment

Sometimes you need to evaluate a DMN table to determine routing before manually overriding a process.

"Evaluate the 'high_risk_transaction' decision table for user 9982 with an amount of $50,000. If the output marks it as 'MANUAL_REVIEW_REQUIRED', find the active user task for process instance 2251799813684444 and assign it to 'jane.doe@company.com'."

  1. Claude calls camunda_decision_definitions_evaluate passing the decision key and the required variables.
  2. Claude receives the evaluated output confirming MANUAL_REVIEW_REQUIRED.
  3. Claude calls list_all_camunda_user_tasks filtering by the target process instance key to retrieve the current task ID.
  4. Claude calls camunda_user_tasks_assign passing the task ID and assignee: "jane.doe@company.com".

Workflow 3: Emergency Suspension of a Process Group

During backend outages, DevOps teams need to quickly halt active orchestrations so jobs do not fail and trigger massive incident logs.

"We have an outage on the shipping provider API. Bulk suspend all active process instances running the 'shipping_fulfillment_v2' definition. Give me the batch operation key so I can track it."

  1. Claude calls camunda_process_instances_bulk_suspend providing a filter for the processDefinitionKey and state ACTIVE.
  2. The Camunda API responds with a 202 Accepted and a batchOperationKey.
  3. Claude returns the key to the user, explaining that the suspension is running asynchronously in the background.

Security and Access Control

Giving AI models access to an enterprise orchestration engine requires strict governance. Truto's MCP servers provide granular controls to lock down the LLM's operational blast radius:

  • Method Filtering: Configure the MCP token with methods: ["read"] to restrict the LLM entirely to GET operations. It will be able to query instances and incidents, but any attempt to complete a task or deploy a resource will be rejected before it hits Camunda.
  • Tag Filtering: Group specific integration resources (like incidents and user_tasks) using config.tool_tags. You can generate an MCP server that only exposes tools tagged with "support", hiding sensitive administrative endpoints like cluster topology resets.
  • Require API Token Auth: By enabling require_api_token_auth: true, possession of the MCP URL is no longer enough. The client connecting to the server must also pass a valid Truto API session token in the authorization header, tying the AI's actions to an authenticated user identity.
  • Expiration (TTL): Set an expires_at ISO datetime when generating the server via the API. Once the timestamp is reached, Cloudflare KV drops the token and a Durable Object alarm cleans up the database record, immediately revoking the LLM's access to Camunda.

Summary

Integrating AI with Camunda shouldn't require your engineering team to write custom polling loops for eventual consistency or build fragile JSON mappers for DMN execution. By using Truto to dynamically generate a Camunda MCP server, you offload the authentication, schema normalization, and tool routing to a managed layer.

Your LLMs get native, typed access to Camunda's complex orchestration APIs, and your engineering team gets to stay focused on core business logic instead of maintaining API boilerplate.

FAQ

How does Truto handle Camunda API rate limits?
Truto does not retry, throttle, or apply backoff on rate limit errors. When Camunda returns an HTTP 429, Truto passes the error to the caller, normalizing the rate limit info into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller is responsible for implementing retry and backoff logic.
Do I need to hand-code MCP tool definitions for Camunda?
No. Truto automatically generates MCP tools from Camunda's underlying resource definitions and documentation records. Query and body schemas are combined into a flat input namespace for the LLM to call easily.
Can I restrict Claude to read-only access for Camunda?
Yes. When generating the MCP server via the Truto UI or API, you can apply method filters like `methods: ["read"]`. This restricts the AI agent to querying data (e.g., listing incidents) while preventing it from modifying state or deploying new processes.

More from our Blog