4,500+ servers built on MCP Fusion
Vinkius

Camunda (BPMN Engine) MCP. Orchestrate and debug complex business workflows.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Camunda (BPMN Engine) MCP on Cursor AI Code Editor MCP Client Camunda (BPMN Engine) MCP on Claude Desktop App MCP Integration Camunda (BPMN Engine) MCP on OpenAI Agents SDK MCP Compatible Camunda (BPMN Engine) MCP on Visual Studio Code MCP Extension Client Camunda (BPMN Engine) MCP on GitHub Copilot AI Agent MCP Integration Camunda (BPMN Engine) MCP on Google Gemini AI MCP Integration Camunda (BPMN Engine) MCP on Lovable AI Development MCP Client Camunda (BPMN Engine) MCP on Mistral AI Agents MCP Compatible Camunda (BPMN Engine) MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Camunda (BPMN Engine) MCP Server connects your AI client to complex business process workflows. Deploy BPMN models, start process instances, manage human tasks, and monitor system incidents directly via natural language.

It lets you act as a technical process orchestrator, managing everything from process definition XML retrieval to job failure and user task completion.

What your AI agents can do

Activate jobs

Polls and activates background jobs, making them available for workers to process.

Assign user task

Assigns a pending human task to a specific user, notifying them that action is needed.

Complete job

Marks an activated job as finished after the work is done.

+ 22 more capabilities included
Start a new process

Initiate a new workflow instance using start_process_instance, passing required data variables.

Complete a user task

Finalize a human-required step by calling complete_user_task after reviewing the necessary data.

Investigate process failures

Search for and retrieve details on process incidents or job failures using search_incidents and get_incident.

Deploy and inspect models

Upload new BPMN or DMN models using deploy_resources or view existing logic via get_process_definition_xml.

Advance job execution

Act on background jobs by activating (activate_jobs), completing (complete_job), or manually failing (fail_job) them.

Map system state

Get the current cluster topology (get_topology) or search for specific process instances (search_process_instances) to map the system state.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

Camunda (BPMN Engine) MCP Server: 25 Tools for Process Management

These 25 tools let your AI agent interact with every part of the Camunda workflow engine—from starting processes to fixing broken jobs and retrieving process definitions.

activate019e3873

activate jobs

Polls and activates background jobs, making them available for workers to process.

assign019e3873

assign user task

Assigns a pending human task to a specific user, notifying them that action is needed.

complete019e3873

complete job

Marks an activated job as finished after the work is done.

complete019e3873

complete user task

Marks a human task as finished and accepts the necessary variables to move the process forward.

deploy019e3873

deploy resources

Uploads and makes available BPMN, DMN, or Form resources for use in workflows.

fail019e3873

fail job

Manually marks a job as failed, which triggers retries or creates an incident log.

get019e3873

get incident

Retrieves specific details about a process incident for troubleshooting.

get019e3873

get process definition xml

Fetches the raw BPMN XML definition for a specific process type.

get019e3873

get process instance

Gets the current status and key details for a running process instance.

get019e3873

get topology

Retrieves the current cluster health and partition status of the Camunda environment.

get019e3873

get user task

Gets the details of a specific pending user task, including its context.

get019e3873

get user task form

Retrieves the linked form needed to complete a user task.

get019e3873

get variable

Gets the specific value of a process or local variable by name.

search019e3873

search groups

Finds and lists available user groups within the Camunda system.

search019e3873

search incidents

Searches for process incidents based on criteria like time or key.

search019e3873

search jobs

Finds and lists job instances, helping you locate background processing failures.

search019e3873

search process definitions

Searches the repository for deployed process models based on keywords or criteria.

search019e3873

search process instances

Searches for running process instances using criteria like ID or status.

search019e3873

search tenants

Searches for multi-tenancy containers to scope your operations.

search019e3873

search user tasks

Finds and lists pending human tasks assigned to users or groups.

search019e3873

search users

Finds and lists user accounts in the system.

search019e3873

search variables

Searches for process or local variables across defined scopes.

start019e3873

start process instance

Starts a brand new process instance, immediately kicking off the workflow defined by the model.

throw019e3873

throw job error

Manually simulates a BPMN error condition from a background job for testing.

unassign019e3873

unassign user task

Removes a pending human task assignment from a specific user.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

  • Import from OpenAPI, Swagger, or YAML specs
  • Create Agent Skills with progressive disclosure
  • Deploy to edge with MCPFusion framework
  • Built in DLP, auth, and compliance on every call
  • Real time usage dashboard and cost metering
  • Publish to catalog or keep private
Start building

Make Your AI Do More

Start with Camunda (BPMN Engine), then connect any of our 4,500+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,500+ others, all in one place
  • Add new capabilities to your AI anytime you want
  • Every connection is secured and compliant automatically
  • Track usage and costs across all your servers
  • Works with Claude, ChatGPT, Cursor, and more
  • New servers added to the catalog every week

What you can do with this MCP connector

This server lets your AI client act like a technical process orchestrator for Camunda. You can use it to manage the whole lifecycle of a business workflow, from defining the process to handling failures.

Start a New Process

Kick off a new workflow instance using start_process_instance and pass any variables it needs. You can also use search_process_instances to find existing running processes, and search_process_definitions to find the models themselves.

Handle User Tasks

If a human has to make a decision, you can search for pending tasks using search_user_tasks, then grab the details of a specific task with get_user_task, or pull the necessary form using get_user_task_form. You can assign a task to a user with assign_user_task, and once they finish, you mark the task complete using complete_user_task and send the data needed to move the process forward.

You can also remove a task assignment using unassign_user_task.

Manage Jobs and Failures

For background jobs, you can locate failures by searching with search_jobs, then activating jobs with activate_jobs or completing them with complete_job. If things go sideways, you can manually mark a job as failed using fail_job or simulate an error with throw_job_error. You can also check the status of a job or instance using get_process_instance or search_jobs.

Inspect System State and Logic

To understand the environment, you can check the cluster health with get_topology or search for users and groups using search_users and search_groups. You can view the raw workflow logic by fetching the BPMN XML definition for a process using get_process_definition_xml, and you can upload new models using deploy_resources.

Troubleshoot Incidents

If a process breaks, you can search for incidents using search_incidents, and then get the specific details of a problem using get_incident. You can also check the status of variables across the system using get_variable or searching with search_variables.

How Camunda (BPMN Engine) MCP Works

  1. 1 First, subscribe to the server and provide your Camunda Base URL and Bearer Token.
  2. 2 Next, ask your AI client to perform a process management action (e.g., 'Start a new order fulfillment process with order ID 550').
  3. 3 The agent calls the appropriate tool (e.g., start_process_instance), executes the action, and returns the resulting process instance ID or task status.

The bottom line is, your AI agent treats the Camunda server like a set of direct APIs, allowing it to execute complex, multi-step workflow logic without manual dashboard interaction.

Who Is Camunda (BPMN Engine) MCP For?

The Operations Engineer who gets tired of clicking through dashboards at 2 AM to find a failed job. The Process Analyst who needs to verify if a specific workflow definition was updated correctly. Developers who need to kick off process runs or complete user tasks during local testing cycles.

Operations Engineer

Uses the server to monitor incidents (search_incidents) and manage job failures (get_incident) through natural language queries.

Process Analyst

Retrieves process definition XML (get_process_definition_xml) or searches for process definitions (search_process_definitions) to verify workflow rules.

Software Developer

Starts test process instances (start_process_instance) and completes user tasks (complete_user_task) to test local development flows.

What Changes When You Connect

  • See the entire process state by running get_process_instance or search_process_instances. You don't have to jump between the Operate dashboard and your IDE just to check if a process is stuck.
  • Diagnose failures instantly. Use search_incidents to find process failures, then get_incident to see exactly which step failed and why. This cuts down troubleshooting time.
  • Move workflows forward without UI clicks. Use complete_user_task or complete_job to finalize human or automated steps directly through your AI client.
  • Manage the system architecture. Check the cluster health and partition status with get_topology to ensure the entire Camunda backend is running correctly.
  • Control the process lifecycle. You can use start_process_instance to kick off a test run, or deploy_resources to update the underlying BPMN models.
  • Pinpoint the failure point. If a job fails, you can use search_jobs to find the instance, and fail_job or throw_job_error to replicate the failure state for debugging.

Real-World Use Cases

01

Diagnosing a stalled invoice approval

An invoice is stuck because the required user task wasn't completed. Your agent first runs search_user_tasks to find pending items, then uses get_user_task to find the specific task details. Finally, you use get_user_task_form to pull the form and complete the task, moving the process forward.

02

Testing a new workflow model

A developer needs to test a new 'Loan Application' workflow. They use search_process_definitions to find the existing model, then deploy_resources to test the updated version, and finally start_process_instance to kick off a test run with dummy data.

03

Investigating a mysterious job failure

A background job failed, stopping the process. You first use search_jobs to locate the failed job instance, then get_incident to find the root cause, and finally use activate_jobs and complete_job to manually re-run the failed job.

04

Auditing process state changes

You need to know what variables were used when a process ran last week. You use search_process_instances to find the correct run, then get_variable to retrieve specific data points like the final approval date.

The Tradeoffs

Treating the system like a database

Trying to find a variable's value by searching the process definition XML (get_process_definition_xml) instead of the running instance data.

Always use get_variable or get_process_instance to get the live variable value. The XML only shows the structure, not the data.

Assuming success after starting a process

Calling start_process_instance and assuming the process finishes. In reality, it just starts, and a human or job must finish it.

After starting, check the status with get_process_instance. If it's waiting on a person, use search_user_tasks to find the task, then get_user_task_form to complete it.

Ignoring the failure path

Just seeing an incident listed by search_incidents and assuming the cause. You need more detail to fix it.

Always follow up search_incidents with get_incident to get the full failure report. Then, use search_jobs to see if job failures contributed.

When It Fits, When It Doesn't

Use this server if your core problem is managing state transitions and complex, multi-step logic. You need to know what happened, why it failed, and how to manually push it to the next step. You're dealing with human approval steps or long-running background jobs. Don't use this if you just need to store data or run simple, isolated calculations—use a dedicated database connector instead. If your goal is only to list all active users, use search_users alone; don't run through the entire process orchestration suite.

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Camunda. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

How we secure it →

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This server provides 25 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

activate_jobs assign_user_task complete_job complete_user_task deploy_resources fail_job get_incident get_process_definition_xml get_process_instance get_topology get_user_task get_user_task_form get_variable search_groups search_incidents search_jobs search_process_definitions search_process_instances search_tenants search_user_tasks search_users search_variables start_process_instance throw_job_error unassign_user_task

Manually checking workflow status shouldn't require jumping between four different dashboards.

Right now, tracking a single process means opening the Camunda Modeler to see the definition, then opening the Operate dashboard to see the active instances, and finally jumping to the Task List to find who needs to approve it. You're copying IDs, switching tabs, and cross-referencing timestamps just to answer, 'Where is this order?'

With this MCP server, your AI client handles the entire sequence. You ask it to 'Check the status of Order 550.' It calls `search_process_instances`, gets the ID, then uses `get_process_instance` to report the current state, all in one conversational turn.

Camunda (BPMN Engine) MCP Server: Manage the entire process lifecycle.

The manual steps that disappear are: logging into the cluster monitor, finding the job ID, searching for the corresponding process instance, and then locating the specific user task. You never have to copy a process key or switch contexts again.

It treats the entire process engine like a backend service layer. You just talk to it. It executes the necessary sequence of API calls—from `search_jobs` to `complete_job`—and gives you the final status.

Common Questions About Camunda (BPMN Engine) MCP

How do I start a process instance using the start_process_instance tool? +

You call start_process_instance and provide the necessary process definition key and initial variables. The server returns the new process instance key and confirms the process has begun running.

What is the difference between search_jobs and search_incidents? +

Use search_jobs when you suspect a background worker failed to run a task. Use search_incidents when the workflow itself encountered a business rule failure or a system error that stopped the process.

Can I complete a user task using the complete_user_task tool? +

Yes, you call complete_user_task and pass the task ID along with any required data variables. This action confirms human input and moves the workflow to the next step.

How do I check the health of the Camunda cluster using get_topology? +

You call get_topology and the server returns the cluster's current map, showing node health, partition status, and overall connectivity.

I need to find the XML definition for a process. Which tool should I use? (get_process_definition_xml) +

Use get_process_definition_xml and provide the process definition ID. It returns the full BPMN XML required for inspection or comparison against other definitions.

How do I assign a user task to a specific user using assign_user_task? +

You use assign_user_task to route work directly to a user. This tool lets you target a specific individual, ensuring the right person sees the pending task and can move the workflow forward.

If a job fails, how do I manage the issue using fail_job and search_jobs? +

You use fail_job to explicitly mark a job as failed, which triggers retries or creates an incident. You then use search_jobs to locate the job instance details and see the failure history.

What should I use to find the XML definition for a process and its variables? +

You need get_process_definition_xml to retrieve the full BPMN XML definition. You can then use get_variable to check the current value of any process or local variable associated with that definition.

Can I start a process instance with specific input data? +

Yes! Use the start_process_instance tool and provide the variables JSON object. The AI will map your data to the process requirements automatically.

How do I find all tasks currently assigned to a specific user? +

You can use the search_user_tasks tool with a filter like {"assignee": "user-id"}. The agent will return a list of all active human tasks for that person.

Is it possible to see why a process instance is stuck? +

Yes. Use search_incidents to find errors in the cluster, and then get_incident with the specific key to see the error message and stack trace.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 25 tools

We've already built the connector for Camunda (BPMN Engine). Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 25 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.