# Orkes Conductor MCP for AI Agents AI Agent Connect

> Orkes Conductor MCP lets your AI agent monitor and manage microservice workflows. It gives you the ability to list definitions, track live executions, and search through history to find specific failures. Instead of hunting through a dashboard, you can ask your agent to find a specific correlation ID or check the status of a running task.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_RrYCpOWyMYAgc2byLtphBnT5DV3QN0zxvc3KjL5z/ai-agent-connect
- **Tags:** orchestration, microservices, workflow-engine, task-scheduling, execution-monitoring

## Description

When you connect this Connector, you stop guessing where a distributed process stalled. You can ask your agent to pull up the status of a specific order or find every failed instance of a data pipeline from last night. It's about having an immediate window into the state of your microservices. You can see exactly which step a workflow is on, what the inputs were, and where the logic branched. If a task throws an exception, the agent can surface the exact error message and the trace history leading up to it. It turns your workflow engine into a searchable knowledge base. This is part of the Vinkius catalog, making it easy to plug into your existing AI setup without extra overhead. You get a direct line to your orchestration layer, letting you debug complex distributed systems using plain English.

## Tools

### list_running
Filter and see which workflow instances are currently active right now. It's the fastest way to check live status.

### get_execution
Pull the full input, output, and trace history for a specific execution. This is your primary tool for deep debugging.

### search_workflows
Query your entire history using filters like correlation ID or status. Use this to find specific needles in the haystack.

### list_workflow_defs
Get a full list of all registered workflow definitions in your cluster. This helps you see the scope of your orchestration.

### get_workflow_def
Pull the specific graph schema and task logic for a named workflow. Use this to understand how a process branches.

### list_task_defs
See every available task definition registered within your environment. This clarifies what actions your workflows can take.

## Prompt Examples

**Prompt:** 
```
Why did the order-processing workflow fail for ID abc-123?
```

**Response:** 
```
The execution for **order-processing** (ID: abc-123) failed at the `payment-validation` task.

**Error Details:**
- **Status:** Failed
- **Error Message:** `Gateway timeout`
- **Input Mapping:** `{"amount": 50.00, "currency": "USD"}`
- **Trace:** The request reached the payment gateway but timed out after 30 seconds.

Would you like me to see the full trace history for this execution?
```

**Prompt:** 
```
Show me all active workflows right now.
```

**Response:** 
```
There are currently **8 active instances** running:

| Workflow | Status | Current Task |
| :--- | :--- | :--- |
| order-processing | Running | payment-validation |
| user-onboarding | Running | email-verification |
| data-pipeline | Running | extract-transform |

(5 instances total for order-processing, 2 for user-onboarding, 1 for data-pipeline)

Want me to check the status of a specific one?
```

**Prompt:** 
```
What is the logic for the user-onboarding workflow?
```

**Response:** 
```
The **user-onboarding** workflow follows this logic:

1. **Start**: Triggered by new user registration.
2. **Task 1**: `validate-user-data` (Checks for valid email and password).
3. **Branch**: If valid, proceed to `create-account`; if invalid, trigger `send-error-notification`.
4. **Task 2**: `send-welcome-email` (Sends a confirmation email).
5. **End**: Mark onboarding as complete.

I can pull the full graph schema if you need more technical details.
```

## Capabilities

### List all workflow definitions
See every registered workflow in your cluster at once.

### Get specific workflow details
Pull the full graph schema and task logic for a named workflow.

### List task definitions
See all registered task definitions available for your orchestration.

### Monitor live running instances
Identify which workflow instances are currently active and executing.

### Fetch deep execution state
Get the full input, output, and trace history for a specific execution.

### Search across all executions
Query your entire history using filters like correlation ID or status.

## Use Cases

### Debugging a failed order
An engineer asks the agent why order #123 failed. The agent uses `get_execution` to find the error and reports that the payment task timed out.

### Checking live sync status
A DevOps lead asks for all active data syncs. The agent uses `list_running` to provide a real-time list of active instances.

### Auditing production failures
A platform engineer asks to find all failed payments today. The agent uses `search_workflows` to filter by status and workflow type.

### Understanding workflow logic
An architect asks how the onboarding flow works. The agent uses `get_workflow_def` to explain the branching logic and task sequence.

## Benefits

- Find failed tasks faster by using `search_workflows` to query your history for specific errors.
- Identify bottlenecks instantly with `list_running` to see where instances are currently stuck.
- Debug production errors with `get_execution` to see exact input and output mappings.
- Audit system architecture with `get_workflow_def` to see full graph schemas for any definition.
- Track your entire library of processes with `list_workflow_defs` to keep a clear inventory.

## How It Works

The bottom line is you get a direct command line for your microservice orchestration layer via your AI agent.

1. Subscribe to the Orkes Conductor MCP on Vinkius.
2. Provide your Orkes Access Key ID, Access Key Secret, and Base URL.
3. Ask your AI client to check your workflows or search for specific failures.

## Frequently Asked Questions

**Can Orkes Conductor MCP help me find why a specific order failed?**
Yes. You can ask your agent to find a specific order ID or correlation ID, and it will pull the exact execution state, showing you the error message and the specific step where it failed.

**How does Orkes Conductor MCP help my DevOps team?**
It gives your team a way to monitor live executions and search through historical failures using plain English instead of clicking through multiple dashboard tabs.

**Can I see all my active workflows at once?**
Absolutely. You can ask your agent to list all running instances, and it will provide a summary of what is currently executing across your cluster.

**Does Orkes Conductor MCP support searching for correlation IDs?**
Yes, it can search across your entire execution history using filters like correlation IDs, workflow types, or specific statuses.

**How do I use Orkes Conductor MCP to check task status?**
Once connected, you just ask your agent which tasks are running. It will query the orchestration layer and report back on the current state of those tasks.

**Can Orkes Conductor MCP show me the logic of a specific workflow?**
Yes. The agent can pull the graph schema for any registered workflow definition, letting you see the branching logic and task sequence in your chat.

**Can I search for failed workflows across my entire history?**
Yes. The search tool supports Elasticsearch query syntax — search by status (FAILED, TIMED_OUT), workflow type, date ranges, or correlation IDs. Ask your agent 'show me all failed workflows from the last 24 hours' and it returns matching executions with their IDs, failure reasons, and timestamps.

**What's the difference between workflow definitions and running instances?**
Definitions are the blueprints — the graph schema with tasks, operators, and branching logic. Running instances are actual executions of those definitions, each with their own input data, current state, and task-by-task progress. Think of definitions as classes and instances as objects.

**Does this integration support triggering new workflow executions?**
Currently, this integration focuses on observability — listing definitions, monitoring running instances, and searching execution history. It does not trigger new workflow executions. For launching workflows, use the Orkes Conductor UI or direct API calls.