Camunda (BPMN Engine) MCP. Orchestrate and debug complex business workflows.
Works with every AI agent you already use
…and any MCP-compatible client
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.
Initiate a new workflow instance using start_process_instance, passing required data variables.
Finalize a human-required step by calling complete_user_task after reviewing the necessary data.
Search for and retrieve details on process incidents or job failures using search_incidents and get_incident.
Upload new BPMN or DMN models using deploy_resources or view existing logic via get_process_definition_xml.
Act on background jobs by activating (activate_jobs), completing (complete_job), or manually failing (fail_job) them.
Get the current cluster topology (get_topology) or search for specific process instances (search_process_instances) to map the system state.
Ask AI about this MCP
Supported MCP Clients
Waiting for input…
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.
019e3873activate jobs
Polls and activates background jobs, making them available for workers to process.
019e3873assign user task
Assigns a pending human task to a specific user, notifying them that action is needed.
019e3873complete job
Marks an activated job as finished after the work is done.
019e3873complete user task
Marks a human task as finished and accepts the necessary variables to move the process forward.
019e3873deploy resources
Uploads and makes available BPMN, DMN, or Form resources for use in workflows.
019e3873fail job
Manually marks a job as failed, which triggers retries or creates an incident log.
019e3873get incident
Retrieves specific details about a process incident for troubleshooting.
019e3873get process definition xml
Fetches the raw BPMN XML definition for a specific process type.
019e3873get process instance
Gets the current status and key details for a running process instance.
019e3873get topology
Retrieves the current cluster health and partition status of the Camunda environment.
019e3873get user task
Gets the details of a specific pending user task, including its context.
019e3873get user task form
Retrieves the linked form needed to complete a user task.
019e3873get variable
Gets the specific value of a process or local variable by name.
019e3873search groups
Finds and lists available user groups within the Camunda system.
019e3873search incidents
Searches for process incidents based on criteria like time or key.
019e3873search jobs
Finds and lists job instances, helping you locate background processing failures.
019e3873search process definitions
Searches the repository for deployed process models based on keywords or criteria.
019e3873search process instances
Searches for running process instances using criteria like ID or status.
019e3873search tenants
Searches for multi-tenancy containers to scope your operations.
019e3873search user tasks
Finds and lists pending human tasks assigned to users or groups.
019e3873search users
Finds and lists user accounts in the system.
019e3873search variables
Searches for process or local variables across defined scopes.
019e3873start process instance
Starts a brand new process instance, immediately kicking off the workflow defined by the model.
019e3873throw job error
Manually simulates a BPMN error condition from a background job for testing.
019e3873unassign 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
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 First, subscribe to the server and provide your Camunda Base URL and Bearer Token.
- 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 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.
Uses the server to monitor incidents (search_incidents) and manage job failures (get_incident) through natural language queries.
Retrieves process definition XML (get_process_definition_xml) or searches for process definitions (search_process_definitions) to verify workflow rules.
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_instanceorsearch_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_incidentsto find process failures, thenget_incidentto see exactly which step failed and why. This cuts down troubleshooting time. - Move workflows forward without UI clicks. Use
complete_user_taskorcomplete_jobto finalize human or automated steps directly through your AI client. - Manage the system architecture. Check the cluster health and partition status with
get_topologyto ensure the entire Camunda backend is running correctly. - Control the process lifecycle. You can use
start_process_instanceto kick off a test run, ordeploy_resourcesto update the underlying BPMN models. - Pinpoint the failure point. If a job fails, you can use
search_jobsto find the instance, andfail_joborthrow_job_errorto replicate the failure state for debugging.
Real-World Use Cases
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.
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.
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.
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
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
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.
Use it with your favorite AI tools
Connect this server to Cursor, Claude, VS Code, and more.
More in this category
Cloudflare Tunnel
Manage Cloudflare Tunnels directly from your AI agent — list, create, and configure secure Zero Trust connections to your private infrastructure.
Truto Unified Calendar
Empower your AI agent with a universal API to read, schedule, and sync events seamlessly across Google, Outlook, and other major calendar providers.
Nalpeiron V10
Protect your software with license management, usage tracking, and entitlement enforcement for desktop and cloud applications.
You might also like
Pixelfed (Instagram Alternative)
Manage your Pixelfed presence — post photos, interact with the community, and track notifications directly from any AI agent.
YesNo
Get instant yes, no, or maybe decisions accompanied by fun GIFs to help your AI agent make choices or break ties.
Clip API
Automate Mexico's leading payment gateway via Clip — generate payment links, manage refunds, and track settlements seamlessly via AI.