Skip to main content
Glama

operaton-mcp

MCP server exposing the full Operaton BPMN/DMN REST API to AI assistants

npm version CI License: Apache 2.0 Node.js

Operaton is an open-source BPMN and DMN workflow engine. operaton-mcp is a Model Context Protocol (MCP) server that exposes 300+ Operaton REST API operations as MCP tools, enabling AI assistants like Claude to interact directly with your workflow engine — deploying processes, managing instances, handling tasks, and querying history.

Features

  • Full REST API coverage — 300+ operations across process definitions, instances, tasks, jobs, incidents, users, history, and decisions

  • Multi-engine support — connect to multiple Operaton instances from a single server

  • Basic Auth & OIDC — supports both HTTP Basic authentication and OAuth2 client credentials (OIDC)

  • Access control guards — configurable operation guards to restrict what the AI can do (OPERATON_GUARD, OPERATON_DENY_RESOURCES, OPERATON_DENY_OPS)

  • Zero-setup with npx — run without installation via npx @operaton/mcp

  • Type-safe — written in TypeScript with strict type checking

Related MCP server: OSOP MCP Server

Quick Start

Prerequisites: Node.js ≥ 22, a running Operaton instance.

Add to your Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows):

{
  "mcpServers": {
    "operaton": {
      "command": "npx",
      "args": ["-y", "@operaton/mcp"],
      "env": {
        "OPERATON_BASE_URL": "http://localhost:8080/engine-rest",
        "OPERATON_USERNAME": "demo",
        "OPERATON_PASSWORD": "demo"
      }
    }
  }
}

Restart Claude Desktop — you're ready to use natural-language commands against your Operaton instance.

Authentication

Basic Auth

Variable

Required

Description

OPERATON_BASE_URL

Yes

Operaton REST API URL, e.g. http://localhost:8080/engine-rest

OPERATON_USERNAME

Yes

Basic Auth username

OPERATON_PASSWORD

Yes

Basic Auth password

OPERATON_ENGINE

No

Operaton engine name (default: default)

OPERATON_SKIP_HEALTH_CHECK

No

Set true to skip startup connectivity check

OIDC / Client Credentials

Variable

Required

Description

OPERATON_BASE_URL

Yes

Operaton REST API URL

OPERATON_CLIENT_ID

Yes

OAuth2 client ID

OPERATON_CLIENT_SECRET

Yes

OAuth2 client secret

OPERATON_TOKEN_URL

Yes

Token endpoint URL

{
  "mcpServers": {
    "operaton": {
      "command": "npx",
      "args": ["-y", "@operaton/mcp"],
      "env": {
        "OPERATON_BASE_URL": "https://operaton.example.com/engine-rest",
        "OPERATON_CLIENT_ID": "mcp-client",
        "OPERATON_CLIENT_SECRET": "your-secret",
        "OPERATON_TOKEN_URL": "https://keycloak.example.com/realms/myapp/protocol/openid-connect/token"
      }
    }
  }
}

For multi-engine deployments, see the Configuration Guide.

Access Control Guards

Guards let you constrain what the AI assistant is allowed to do. They are enforced at the MCP dispatch layer — blocked calls never reach Operaton.

OPERATON_GUARD — overall mode

Value

Effect

(unset) or unrestricted

All operations permitted (default)

read-only

Only read operations permitted; all mutating tools are hidden from the AI and blocked if called directly

safe

Read and reversible mutations permitted; irreversible operations (delete, deploy, migrate-execute) are hidden from the AI and blocked if called directly

"env": {
  "OPERATON_GUARD": "read-only"
}

OPERATON_DENY_RESOURCES — block specific domains

Comma-separated list of resource domains to deny entirely. Both reads and writes in the named domain are blocked.

Valid domains: process-definitions, deployments, instances, tasks, jobs, incidents, users-groups, decisions, migrations, infrastructure

"env": {
  "OPERATON_DENY_RESOURCES": "users-groups,decisions"
}

OPERATON_DENY_OPS — block specific operation classes

Comma-separated list of operation classes to deny regardless of domain.

Valid classes: read, create, update, delete, suspend-resume, deploy, migrate-execute, migrate-control

"env": {
  "OPERATON_DENY_OPS": "delete,deploy"
}

Combining guards

All three env vars can be set together. The most restrictive rule that matches a call wins. Precedence: OPERATON_GUARD → OPERATON_DENY_RESOURCES → OPERATON_DENY_OPS.

Guards are enforced at two layers. Forbidden tools are hidden from the tool list — the AI never sees them and cannot propose their use. If a forbidden tool is called directly despite being absent from the list, the call-time guard rejects it as a second line of defence. When a call is blocked, the MCP client receives an isError response naming the blocked operation and the guard rule that triggered. The server logs a WARN entry with full detail including a remediation hint.

Production tip: Use OPERATON_GUARD=safe to prevent the AI from accidentally deleting definitions or executing migrations while still allowing it to start instances, complete tasks, and manage jobs.

Available Tools

processDefinition

Manage deployed process definitions — browse, inspect, suspend, and delete BPMN definitions.

  • list — query definitions with optional filters (key, name, version, tenant); count total matches

  • get by ID / key — retrieve definition metadata for a specific ID or latest by key

  • get XML — fetch BPMN 2.0 XML for a definition by ID or key

  • statistics — process-level and activity-level statistics across all running instances

  • suspend by key — suspend or resume all instances belonging to a definition

  • delete by ID / key — remove a definition (and optionally its instances and history)

  • restart instances — restart historic process instances synchronously or asynchronously

  • set history TTL — update the history time-to-live for a definition

  • get called processes — list static called process definitions for a given definition

deployment

Deploy, inspect, and manage Operaton deployments (BPMN, DMN, CMMN, and form files).

  • create — upload a BPMN/DMN/CMMN resource to create a new deployment

  • list — query deployments with optional filters; count total matches

  • get by ID — retrieve metadata for a specific deployment

  • list resources — list all resources included in a deployment

  • redeploy — create a new deployment from the resources of an existing one

  • delete — remove a deployment by ID

processInstance

Start and manage the lifecycle of running process instances.

  • start — start a new instance by definition ID or key, with optional business key and variables

  • list — query active instances with filters; count total matches

  • get — retrieve metadata for a specific instance

  • get activity tree — inspect the current activity instance hierarchy

  • suspend / resume — suspend or resume execution of an instance or a group of instances

  • delete — terminate and remove a process instance

  • get / set variables — read or write individual or multiple process variables

  • set suspension — bulk suspend/resume by definition ID, key, or tenant

task

Query and manage the full lifecycle of user tasks.

  • list — query tasks with rich filter criteria; count total matches

  • get — retrieve a task by ID

  • claim / unclaim — assign or release a task

  • complete — complete a task with optional output variables

  • delegate — delegate a task to another user

  • resolve — resolve a delegated task back to the owner

  • set assignee — directly set or change task assignee

  • create / update — create a standalone task or update task properties

  • get / set variables — read or write task-local variables

  • throw BPMN error — trigger a BPMN error boundary event from a task

job

Inspect and control asynchronous jobs (timers, async continuations, retries).

  • list — query jobs with filters; count total matches

  • get — retrieve a job by ID

  • trigger execution — execute a job immediately (bypass timer)

  • suspend / resume — suspend or resume a job

  • set retries — update the retry count on a failed job

  • get stack trace — retrieve the exception stack trace for a failed job

jobDefinition

Manage job definitions — the templates from which individual jobs are created.

  • list — query job definitions with filters

  • get — retrieve a job definition by ID

  • set suspension — suspend or activate job definitions by process definition

incident

Query and resolve process incidents (failed jobs, failed external tasks, etc.).

  • list — query open incidents with filters; count total matches

  • get — retrieve an incident by ID

  • resolve — resolve an open incident

user

Manage Operaton users and their credentials.

  • list — query users with filters

  • get profile — retrieve a user's profile information

  • create — create a new user with profile and credentials

  • update profile — update a user's display name and email

  • update password — change a user's password

  • delete — remove a user

  • unlock — unlock a user account after too many failed logins

group

Manage Operaton groups and their memberships.

  • list — query groups with filters

  • create / delete — create or remove a group

  • add / remove member — manage group membership

history

Query the audit trail of completed and historic process data.

  • list process instances — query finished or active process instances in history

  • list activity instances — query historic activity executions

  • list task instances — query historic task completions and assignments

  • list variable instances — query historic variable values

  • list incidents — query historic incidents (including resolved)

  • list job logs — query historic job execution log entries

  • list user operations — query the audit log of user operations (claims, completions, etc.)

decision

Deploy and evaluate DMN decision tables.

  • list — query deployed decision definitions

  • get by key — retrieve a decision definition by key

  • get XML by key — fetch DMN XML for a decision

  • evaluate — evaluate a decision table with input variables

  • list requirements — list decision requirement diagrams (DRDs)

migration

Discover, plan, execute, monitor, and audit process instance migrations between definition versions.

  • listMigratable (processInstance_listMigratable) — list active instances eligible for migration with per-instance eligibility and call-activity blocking conditions

  • getMigrationCandidates (processDefinition_getMigrationCandidates) — compare source and target definition activities; returns auto-mappable pairs, unmapped source activities, and new target activities

  • generatePlan (migration_generatePlan) — generate a migration plan with auto-mapped instructions and a list of unmapped activities requiring explicit mapping

  • validatePlan (migration_validatePlan) — validate a migration plan against a set of instances; returns typed errors, sampled-validation flag, and consequence disclosure

  • executeBatch (migration_executeBatch) — execute a migration plan asynchronously with auto-chunking; supports dry-run mode

  • suspendBatch (migration_suspendBatch) — suspend one or more active migration batches

  • resumeBatch (migration_resumeBatch) — resume one or more suspended migration batches

  • deleteBatch (migration_deleteBatch) — cancel (delete) one or more migration batches

  • listBatches (migration_listBatches) — list active migration batches, optionally filtered by suspended state

  • awaitBatch (migration_awaitBatch) — poll migration batches until completion or timeout; returns aggregated progress

  • getBatchStatus (migration_getBatchStatus) — get current job counts and suspension state for a single batch

  • getBatchFailures (migration_getBatchFailures) — retrieve per-instance failure details including error messages and stack traces

  • retryFailedJobs (migration_retryFailedJobs) — reset retries on all failed migration jobs in one or more batches

  • getBatchSummary (migration_getBatchSummary) — aggregate post-migration summary across batch IDs: submitted, succeeded, failed, duration

  • listAuditEntries (migration_listAuditEntries) — query the user operation log for migration audit entries with operator, timestamp, and definition filters

  • listHistoricBatches (migration_listHistoricBatches) — query the history log for completed migration batches with date-range and completion-state filters

Example Prompts

Deployments & Definitions

"Deploy this BPMN file to Operaton and name it loan-approval-v3." "List all deployed versions of the invoice-approval process." "Show me the BPMN XML for the latest version of the onboarding process."

Process Instances

"Start a new invoice-approval process with business key INV-2024-001 and set the amount variable to 15000." "List all active instances of the loan-approval process." "What variables are currently set on process instance abc-123?"

User Tasks

"Show me all unassigned tasks for the approvers group." "Claim task task-456 for user john.doe." "Complete the approval task for invoice INV-2024-001 and set approved = true."

Operations & Incidents

"Are there any failed jobs with no retries left?" "Reset the retry count to 3 for job job-789 and trigger immediate execution." "List all open incidents for the payment-processing process."

History & Audit

"Show me all completed invoice-approval instances from last week." "Who completed the approval task for business key INV-2024-001, and when?"

Decisions

"Deploy this DMN decision table for loan eligibility checking." "Evaluate the credit-check decision with income = 50000 and creditScore = 720."

Development

# Install dependencies (triggers code generation automatically)
npm install

# Run code generation manually
npm run generate

# Build (generate + compile + alias rewrite)
npm run build

# Watch mode for local development
npm run dev

# Run all tests (unit + smoke)
npm test

# Run integration tests (requires live Operaton instance)
OPERATON_BASE_URL=http://localhost:8080/engine-rest \
OPERATON_USERNAME=demo \
OPERATON_PASSWORD=demo \
npm run test:integration

Project Structure

src/
  index.ts          — MCP server entry point
  config.ts         — Configuration loading (env vars + config file)
  auth/
    token-manager.ts — OIDC client credentials token manager
  http/
    client.ts       — Operaton HTTP client (Basic + OIDC auth)
    errors.ts       — Error normalization with BPM-domain hints
  generated/        — Build artifact (gitignored); produced by npm run generate
  tools/            — Curated tool wrappers (hand-written)
config/
  tool-manifest.json         — Full curation manifest (name, description, frMapping per operationId)
  tool-manifest.fixture.json — Fixture for development/testing
resources/
  operaton-rest-api.json     — Authoritative OpenAPI 3.0.2 spec (never modify)
scripts/
  generate.ts       — Code generation pipeline
docs/
  configuration.md  — Full configuration reference

Out of Scope

The following capabilities are not available in the current release:

  • Autonomous monitoring — AI-initiated process health watching and alerting (planned: Vision phase)

  • BPMN generation — natural language → BPMN authoring and AI-assisted process design (planned: Growth phase)

  • Prompt templates — guided scenario workflows for common operational tasks (planned: Growth phase)

  • UI or dashboard — no web interface; operaton-mcp is a pure MCP server

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines on how to contribute, commit conventions, and the PR process.

License

Apache 2.0 — see LICENSE for details.

Available Tools

105 tools
decision_deployB

Deploy a DMN decision artifact to Operaton. Provide DMN XML, a .dmn filename, and a deployment name. Returns deployment metadata and deployed decision definition keys.

Inputs: bpmn-content (required), deployment-name (required), tenant-id, bpmn-filename, +1 more.

decision_evaluateA

Evaluate a deployed DMN decision table by key with typed input variables. Returns the matched rule outputs. Used to test decision logic through AI.

Inputs: key (required).

decision_getByKeyB

Retrieve the latest deployed version of a decision definition by its key. Returns key, id, version, and deployment details.

Inputs: key (required).

decision_getXmlByKeyA

Retrieve the DMN XML of the latest version of a decision definition by key. Use to inspect the current decision table logic.

Inputs: key (required).

decision_listC

List deployed DMN decision definitions. Filter by key, name, version, or tenant. Returns decision key, id, version, and deployment info.

Inputs: key, name, sortBy, keyLike, +23 more.

decisionRequirements_listC

List deployed Decision Requirements Definitions (DRDs). DRDs describe dependencies between decision tables in a complex DMN model.

Inputs: key, name, sortBy, keyLike, +16 more.

deployment_countC

Count deployments matching filter criteria. Supports same filters as deployment list.

Inputs: id, name, after, before, +6 more.

deployment_createA

Deploy a BPMN or DMN artifact to Operaton. Provide the XML content, filename (.bpmn or .dmn), and a deployment name. Returns deployment ID and deployed definition keys.

Inputs: bpmn-content (required), deployment-name (required), tenant-id, bpmn-filename, +1 more.

deployment_deleteA

Delete a deployment by ID. Set cascade=true to also delete running instances and history. Use skipCustomListeners and skipIoMappings to bypass lifecycle hooks.

Inputs: id (required), cascade, skipIoMappings, skipCustomListeners.

deployment_getByIdA

Retrieve a deployment by its ID. Returns deployment name, source, time, and tenant ID.

Inputs: id (required).

deployment_listC

List deployments in the engine. Filter by name, source, deployment time range, or tenant. Returns deployment ID, name, and time for each deployment.

Inputs: id, name, after, before, +10 more.

deployment_listResourcesB

List all resources (BPMN files, DMN files, forms) included in a deployment by deployment ID.

Inputs: id (required).

deployment_redeployB

Redeploy an existing deployment, optionally selecting specific resources. Creates a new deployment from resources of a previous deployment.

Inputs: id (required).

group_addMemberB

Add a user to an Operaton group by user ID and group ID. The user will receive task assignments for this group's candidate tasks.

Inputs: id (required), userId (required).

group_createB

Create a new Operaton group with an id, name, and optional type. Groups are used to manage candidate task assignments and authorization.

Inputs: no named parameters.

group_deleteB

Delete an Operaton group by ID. Returns confirmation on success. Returns a not-found error if the group does not exist.

Inputs: id (required).

group_listC

Query Operaton groups by id, name, type, or member user ID. Returns group details for each matching group.

Inputs: id, idIn, name, type, +7 more.

group_removeMemberB

Remove a user from an Operaton group. The user will no longer receive task assignments for this group's candidate tasks.

Inputs: id (required), userId (required).

history_listActivityInstancesC

Query historic activity instances for a process instance. Returns activityId, name, type, startTime, endTime, duration, and assignee for user tasks.

Inputs: sortBy, canceled, finished, sortOrder, +18 more.

history_listIncidentsB

Query historic incidents including resolved ones. Filter by process instance, type, or resolution state. Use for post-incident analysis.

Inputs: open, sortBy, deleted, resolved, +25 more.

history_listJobLogsC

Query historic job execution logs for a process instance. Returns log entries with timestamp, job type, retries, and exception details.

Inputs: jobId, logId, sortBy, hostname, +22 more.

history_listProcessInstancesC

Query historic process instances by key, business key, state (active/completed), or date range. Returns id, definitionKey, startTime, endTime, duration, and state.

Inputs: active, sortBy, finished, completed, +51 more.

history_listTaskInstancesC

Query historic task instances by process instance, definition key, assignee, or completion state. Returns name, assignee, endTime, duration, and process instance ID.

Inputs: sortBy, taskId, assigned, finished, +59 more.

history_listUserOperationsC

Query the user operation audit log. Returns who performed what operation (claim, complete, delete) on which entity and when.

Inputs: jobId, sortBy, taskId, userId, +23 more.

history_listVariableInstancesC

Query historic variable instances by process instance ID or variable name. Returns variable name, type, value, and the activity instance that set it.

Inputs: sortBy, taskIdIn, sortOrder, maxResults, +21 more.

incident_countB

Count active incidents matching filter criteria. Use to gauge operational health before investigating individual incidents.

Inputs: activityId, incidentId, tenantIdIn, executionId, +13 more.

incident_getByIdA

Retrieve a single incident by ID. Returns type, message, cause, root cause, process definition ID, and activity ID.

Inputs: id (required).

incident_listC

List active incidents in the engine. Filter by type, message, process definition, or activity. Incidents indicate failed jobs, failed scripts, or custom conditions.

Inputs: sortBy, sortOrder, activityId, incidentId, +17 more.

incident_resolveA

Resolve an incident by ID, clearing the error state and allowing the process to continue or be retried. Only applicable to custom incident types.

Inputs: id (required).

job_countB

Count jobs matching filter criteria. Use to assess backlog size before listing.

Inputs: jobId, active, jobIds, timers, +23 more.

jobDefinition_getB

Retrieve a single job definition by ID. Returns activity details, process definition, and suspension state.

Inputs: id (required).

jobDefinition_listC

List job definitions with filters. Returns timer and async service task definitions with their current suspension state and override priority.

Inputs: active, sortBy, jobType, sortOrder, +12 more.

jobDefinition_setSuspensionB

Suspend or resume all jobs for a job definition. Use includeJobs=true to also suspend/resume active job instances for this definition.

Inputs: id (required).

job_getB

Retrieve a single job by ID. Returns id, type, retries, dueDate, exceptionMessage, and process instance details.

Inputs: id (required).

job_getStacktraceB

Retrieve the exception stacktrace for a failed job. Use to diagnose the root cause of job failures.

Inputs: id (required).

job_listC

List jobs with optional filters: process instance, job definition, exception presence, retries, and due date range. Returns id, type, retries, dueDate, and exceptionMessage.

Inputs: jobId, active, jobIds, sortBy, +27 more.

job_setRetriesB

Set the retry count for a failed job. Use to reset retries after fixing the root cause of a job failure. Set to 1 or more to re-enable execution.

Inputs: id (required).

job_setSuspensionB

Suspend or resume a specific job by ID. Suspended jobs will not be executed by the job executor. Resume to re-enable execution.

Inputs: id (required).

job_triggerExecutionB

Trigger immediate execution of a specific job. Use to manually run a scheduled or async job without waiting for its due date.

Inputs: id (required).

migration_awaitBatchA

Poll migration batch(es) until all complete or timeout is reached. Returns COMPLETED or TIMEOUT with aggregated progress (completed, failed, pending job counts).

Inputs: batchIds (required), timeoutSeconds (required), pollIntervalSeconds.

migration_deleteBatchB

Cancel (delete) one or more migration batches by ID. Returns per-batch success or error.

Inputs: batchIds (required), cascade.

migration_executeBatchA

Execute a migration plan asynchronously. Auto-chunks large instance lists. Returns batch IDs and chunk submission errors. Supports dryRun mode (validates without creating batches).

Inputs: plan (required), instanceIds (required), dryRun, batchSize, +1 more.

migration_generatePlanA

Generate a migration plan from a source to target process definition. Returns auto-mapped activity instructions and a list of unmapped source activities requiring explicit mapping.

Inputs: sourceProcessDefinitionId (required), targetProcessDefinitionId (required), updateEventTriggers.

migration_getBatchFailuresA

Retrieve per-instance failure details for one or more migration batches. Returns processInstanceId, jobId, failureType (EXHAUSTED_RETRIES), errorMessage, and stacktrace.

Inputs: batchIds (required).

migration_getBatchStatusB

Get current status of a single migration batch: totalJobs, jobsCreated, jobsCompleted, jobsFailed, suspended.

Inputs: batchId (required).

migration_getBatchSummaryA

Aggregate post-migration summary across one or more batch IDs: totalSubmitted, succeeded, failed, duration. Suitable for deployment sign-off records.

Inputs: batchIds (required).

migration_listAuditEntriesA

Query the Operaton user operation log for migration audit entries. Returns operatorId, timestamp, operationType. Filters: processDefinitionKey, date range.

Inputs: maxResults, startedAfter, startedBefore, processDefinitionKey.

migration_listBatchesA

List active migration batches (type MIGRATE_PROCESS_INSTANCE). Optionally filter by suspended state.

Inputs: suspended, maxResults.

migration_listHistoricBatchesB

Query historic migration batches from the Operaton history log. Filters: completion status, date range. Always scoped to MIGRATE_PROCESS_INSTANCE batch type.

Inputs: completed, maxResults, startedAfter, startedBefore.

migration_resumeBatchA

Resume one or more suspended migration batches by ID. Returns per-batch success or error.

Inputs: batchIds (required).

migration_retryFailedJobsA

Reset retries on all failed migration jobs in one or more batches. Returns total retried count and per-batch breakdown.

Inputs: batchIds (required), retries.

migration_suspendBatchB

Suspend one or more migration batches by ID. Returns per-batch success or error.

Inputs: batchIds (required).

migration_validatePlanA

Validate a migration plan against a set of process instances. Returns typed errors, sampled-validation flag, and consequence disclosure (timers, external tasks, cancellations).

Inputs: plan (required), instanceIds (required), instructions, totalInstanceCount.

processDefinition_activityStatsB

Get activity-level statistics for a process definition: instance counts per activity, failed job counts, and incident counts. Useful for bottleneck analysis.

Inputs: id (required), incidents, failedJobs, incidentsForType.

processDefinition_countB

Count deployed process definitions matching filter criteria. Supports same filters as list. Use before listing to plan pagination.

Inputs: key, name, active, keysIn, +28 more.

processDefinition_deleteByIdA

Delete a process definition by ID. Set cascade=true to also delete running instances, history, and jobs. Fails if instances exist and cascade is false.

Inputs: id (required), cascade, skipIoMappings, skipCustomListeners.

processDefinition_deleteByKeyB

Delete all versions of a process definition by key. Set cascade=true to remove all instances and history. Fails if active instances exist and cascade is false.

Inputs: key (required), cascade, skipIoMappings, skipCustomListeners.

processDefinition_deployB

Deploy a BPMN process definition to Operaton. Provide BPMN or DMN XML, a filename, and a deployment name. Returns deployment metadata and deployed definition keys.

Inputs: bpmn-content (required), deployment-name (required), tenant-id, bpmn-filename, +1 more.

processDefinition_getByIdA

Retrieve a single process definition by its unique ID. Returns full metadata: key, version, deployment ID, resource name, and tenant.

Inputs: id (required).

processDefinition_getByKeyA

Retrieve the latest deployed version of a process definition by its key. Returns full metadata including version, deployment ID, and start form key.

Inputs: key (required).

processDefinition_getCalledProcessesA

List all process definitions statically called (via call activity) by a given process definition ID. Useful for dependency analysis.

Inputs: id (required).

processDefinition_getMigrationCandidatesB

Compare source and target process definition activities. Returns auto-mappable pairs, unmapped source activities, new target activities. Optionally checks required variable presence on supplied instance IDs.

Inputs: sourceProcessDefinitionId (required), targetProcessDefinitionId (required), instanceIds, requiredVariables.

processDefinition_getXmlByIdA

Retrieve the BPMN 2.0 XML source of a process definition by ID. Useful for inspecting or debugging process models.

Inputs: id (required).

processDefinition_getXmlByKeyA

Retrieve the BPMN 2.0 XML source of the latest deployed version of a process definition by key.

Inputs: key (required).

processDefinition_listC

List deployed process definitions. Filter by key, name, version, category, or tenant. Returns key, id, version, and deployment info for each definition.

Inputs: key, name, active, keysIn, +32 more.

processDefinition_restartInstancesC

Restart one or more process instances for a process definition. Use to re-execute failed or completed instances from a given activity.

Inputs: id (required).

processDefinition_restartInstancesAsyncB

Restart process instances asynchronously (returns a batch job). Use when restarting many instances to avoid timeout.

Inputs: id (required).

processDefinition_setHistoryTtlByIdC

Update the history time-to-live (in days) for a specific process definition version by ID. Controls how long historic instances are retained.

Inputs: id (required).

processDefinition_setHistoryTtlByKeyB

Update the history time-to-live (in days) for all versions of a process definition by key. Controls historic data retention.

Inputs: key (required).

processDefinition_statisticsB

Get process definition statistics across all deployed definitions: instance counts, failed job counts, and incident counts per definition.

Inputs: incidents, failedJobs, rootIncidents, incidentsForType.

processDefinition_suspendByKeyB

Suspend or activate a process definition by key. Suspended definitions cannot be started. Set includeProcessInstances=true to also suspend all running instances.

Inputs: key (required).

processInstance_countB

Count active process instances matching filter criteria. Supports same filters as list. Use before listing to plan pagination.

Inputs: active, suspended, variables, incidentId, +26 more.

processInstance_deleteB

Delete (cancel) an active process instance by ID. Accepts an optional deletion reason that is recorded in history. Returns confirmation on success.

Inputs: id (required), skipIoMappings, failIfNotExists, skipSubprocesses, +1 more.

processInstance_getA

Retrieve a single active process instance by ID. Returns id, definitionKey, businessKey, state, startTime, and tenant.

Inputs: id (required).

processInstance_getActivityTreeB

Retrieve the activity instance tree for a process instance. Shows current active activities, called sub-processes, and execution structure.

Inputs: id (required).

processInstance_getVariableB

Retrieve a single named variable from an active process instance. Returns the variable value, type, and scope.

Inputs: id (required), varName (required), deserializeValue.

processInstance_getVariablesB

Retrieve all variables for an active process instance. Returns each variable with its name, type, and value. Use to inspect current execution state.

Inputs: id (required), deserializeValues.

processInstance_listC

List active process instances with optional filters: business key, definition key/id, state, variable values, and tenant. Returns id, definitionKey, state, and business key.

Inputs: active, sortBy, sortOrder, suspended, +30 more.

processInstance_listMigratableA

List active process instances eligible for migration. Returns per-instance eligibility with call-activity blocking conditions. Filters: definition key, source version, business key pattern.

Inputs: processDefinitionKey (required), maxResults, sourceVersion, businessKeyLike.

processInstance_setSuspensionA

Suspend or resume a process instance by ID. Set suspended=true to pause execution, suspended=false to resume. Suspended instances cannot advance until resumed.

Inputs: id (required).

processInstance_setVariableC

Set a single named variable on an active process instance. Provide the variable name, value, and type. Overwrites any existing value for that variable.

Inputs: id (required), varName (required).

processInstance_setVariablesB

Add or update multiple variables on an active process instance in a single call. Provide a map of variable names to typed values. Existing variables are overwritten.

Inputs: id (required).

processInstance_startA

Start a new process instance by definition key (latest version). Accepts optional business key and typed variables. Returns instance ID, state, and definition info.

Inputs: key (required).

processInstance_startByIdA

Start a new process instance by process definition ID. Use when a specific definition version is required. Returns instance ID, state, and definition info.

Inputs: id (required).

task_claimA

Claim a user task for the specified user. After claiming, the task is assigned to that user and removed from candidate group queues.

Inputs: id (required).

task_completeB

Complete a user task, advancing the process to the next step. Optionally provide output variables to pass to the process. Returns confirmation.

Inputs: id (required).

task_countC

Count user tasks matching filter criteria. Supports same filters as task list. Useful for workload sizing.

Inputs: name, owner, active, taskId, +94 more.

task_createB

Create a standalone user task not attached to a process instance. Useful for ad-hoc work items. Provide name, assignee, priority, and due date.

Inputs: no named parameters.

task_delegateB

Delegate a user task to another user. The original owner retains ownership but the delegated user can complete it. Use for escalation workflows.

Inputs: id (required).

task_getByIdB

Retrieve a single user task by its ID. Returns task name, assignee, due date, priority, and process instance.

Inputs: id (required).

task_getVariablesC

Retrieve all variables associated with a user task. Returns variables from task scope and parent process scope.

Inputs: id (required), deserializeValues.

task_listC

Query user tasks with rich filtering: by assignee, candidate group, process instance, variables, due date, and more. Returns task metadata for operator review.

Inputs: name, owner, active, sortBy, +98 more.

task_resolveA

Resolve a delegated task, returning ownership to the original owner. Use after the delegate has completed their work to restore normal ownership.

Inputs: id (required).

task_setAssigneeB

Directly assign a user task to a specific user without going through the claim workflow. Overwrites any existing assignee.

Inputs: id (required).

task_setVariablesC

Add or update multiple variables on a user task. Variables set here are available in the process after task completion. Provide typed variable values.

Inputs: id (required).

task_throwBpmnErrorB

Throw a BPMN error from a user task, triggering the boundary error event on the process. Use to signal an exceptional condition during task execution.

Inputs: id (required).

task_unclaimA

Unclaim a user task, removing the current assignee. The task returns to the candidate group queue and can be claimed by another user.

Inputs: id (required).

task_updateA

Update metadata of a user task: name, description, assignee, due date, priority, or parent task. Does not advance the task in the workflow.

Inputs: id (required).

user_createB

Create a new Operaton user account with profile (id, firstName, lastName, email) and credentials (password). Returns confirmation on success.

Inputs: no named parameters.

user_deleteB

Delete an Operaton user account by ID. Returns confirmation on success. Returns a not-found error if the user does not exist.

Inputs: id (required).

user_getProfileA

Retrieve the profile of a specific Operaton user by ID. Returns firstName, lastName, and email.

Inputs: id (required).

user_listC

Query Operaton users by id, firstName, lastName, email, or group membership. Returns profile info for each matching account.

Inputs: id, idIn, email, sortBy, +11 more.

user_unlockA

Unlock a locked Operaton user account. Use when a user has been locked due to failed login attempts.

Inputs: id (required).

user_updatePasswordB

Update the password for an existing Operaton user. Requires the current password for non-admin users. Returns confirmation on success.

Inputs: id (required).

user_updateProfileC

Update the profile of an existing Operaton user: firstName, lastName, or email. Returns confirmation on success.

Inputs: id (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3/5.0

    Scored across 105 tools

    Disambiguation3/5

    Most tools target distinct resource/action pairs, and ID-vs-key variants are generally explained. However, deployment_create, processDefinition_deploy, and decision_deploy overlap on artifact deployment, while task_setAssignee overlaps with task_claim and task_update; at 105 tools, misselection is likely.

    Naming Consistency4/5

    Names mostly follow a predictable resource_action pattern such as task_complete, processInstance_get, and migration_executeBatch. There are minor deviations in casing and operation grouping (e.g. getById/getByKey camelCase actions, deployment_create vs processDefinition_deploy), but the convention remains readable.

    Tool Count1/5

    105 tools is far beyond a well-scoped MCP surface and is extreme for this domain. Many ID/key variants, migration batch lifecycle operations, and separate list/count/get tools could have been consolidated.

    Completeness4/5

    The surface covers core BPM lifecycle operations widely: definitions, instances, tasks, jobs, incidents, deployments, history, users, groups, decisions, and migration. Some notable gaps remain, such as external tasks, message/signal correlation, tenant/authorization management, and form handling, but agents can work around most core workflows.

    Maintenance

    ActivityActive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI assistants to access and execute automated decision services from IBM Decision Intelligence or IBM Automation Decision Services. It exposes deployed decision operations as tools for platforms like Claude Desktop and IBM watsonx Orchestrate.
      28 npm
      7
      Apache 2.0
    • A
      license
      Not graded
      quality
      F
      maintenance
      Enables AI agents to manage OSOP workflows by providing tools for validation, execution, testing, and optimization. It also supports converting workflows between OSOP and external formats like GitHub Actions, BPMN, and Airflow DAGs.
      1
      Apache 2.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables AI agents to integrate with IBM Business Automation Workflow by exposing workflow REST services as MCP tools, allowing natural language interaction with business automation capabilities.
      11
      Apache 2.0