# CrewAI Platform MCP

> CrewAI Platform provides full control over multi-agent workflows. List and manage entire agent teams, start complex automated runs with specific inputs, and track every task in real time from a single chat window. You can audit agents' roles, view the execution status of active runs, or even manually stop them when they go off track.

## Overview
- **Category:** superpower
- **Price:** Free
- **Tags:** multi-agent, autonomous-agents, workflow-automation, llm-orchestration, task-execution

## Description

This MCP lets you orchestrate whole teams of AI agents through natural conversation. Instead of building custom API calls for every step, you define the crew structure—who reports to whom and what their specific roles are. You kick off a complex workflow with just a JSON payload describing the initial problem (like 'Analyze Q3 sales data'). The system handles the handoffs: Agent A writes a report, Agent B critiques it, and Agent C compiles the final summary. If anything breaks or needs changing midway, you can inspect the live run status or even send an interrupt signal to hard-stop the process. Connecting this MCP via Vinkius gives your agent access to the entire catalog of capabilities, making multi-agent orchestration predictable right from your chat client.

## Tools

### get_inputs
Identify bounded inputs required to kickoff a crew

### get_status
Retrieve explicit execution state tracing limits

### kickoff_crew
Starts a new multi-agent workflow by accepting a structured JSON payload that defines the initial customer goal or input.

## Prompt Examples

**Prompt:** 
```
List all crews in my account
```

**Response:** 
```
I found 3 crews: 'Market-Research-Team' (ID: crew_abc), 'Content-Creation-Squad' (ID: crew_def), and 'Data-Analysis-Group' (ID: crew_ghi). Which one would you like to inspect?
```

**Prompt:** 
```
Kickoff crew 'crew_abc' with input: {'topic': 'AI Trends 2024'}
```

**Response:** 
```
Crew 'crew_abc' has been kicked off! New Run ID: 'run_123'. The agents are now starting their autonomous research on 'AI Trends 2024'. I can monitor the status for you.
```

**Prompt:** 
```
What is the backstory of agent 'agent_789'?
```

**Response:** 
```
Retrieving agent details... Agent 'agent_789' is a 'Senior Research Analyst'. Backstory: 'Expert in gathering and synthesizing complex data from multiple sources to provide actionable insights.'
```

## Capabilities

### Manage Agent Teams
List all deployed workflows and extract pure JSON blueprints that map out every connected agent.

### Start Autonomous Runs
Trigger complex, multi-agent processing immediately using dynamic inputs to start a new workflow run.

### Monitor Live Execution
Retrieve the current physical state of active workflows, tracking agents as they complete sequential or parallel tasks.

### Audit Agents and Tasks
Enumerate all available roles (agents) and modular operations (tasks) to verify their backstories and intended outcomes.

### Control Workflow State
Send instant signals to halt running processes or manage the context boundaries used by the underlying LLMs.

### Inspect Webhooks
View specific validation criteria for asynchronous results and track where agent outcomes go after standard JSON formatting.

## Use Cases

### Market Research Deep Dive
A Product Manager needs to synthesize competitor data. They call `kickoff_crew` with a JSON input: {'topic': 'Competitor X pricing changes'}. The system runs the research, and they receive a consolidated report in minutes.

### Debugging Failed Workflows
A Developer finds a run failing. They use `get_run_status` to check the explicit cloud logs and immediately pinpoint whether the failure is due to an API rate limit or bad input data.

### Verifying Agent Roles
An AI Architect needs proof that their 'Legal Reviewer' agent has specific guardrails. They use `get_agent` to retrieve the structured rules and billing constraints, confirming compliance before launch.

### Building a Task Catalog
A DevOps team member wants to see all possible integration points. They run `list_tasks` to get an automated list of every available modular operation, ensuring no critical step is forgotten.

## Benefits

- Stop guessing if your complex workflow is stuck. Use `get_run_status` to see the explicit cloud logging and vault limits for active runs, giving you total visibility into execution flow.
- Need to start a test run? Instead of writing boilerplate code, use `kickoff_crew` with a simple JSON payload, triggering an autonomous workflow instantly.
- Audit your team structure before deployment. Run `list_agents` and `get_agent` to see every agent's rules and backstories, ensuring the right role is assigned the job.
- Control failure points directly. If a run goes wild or hits a loop, you can use `cancel_run` to hard-stop the process instantly without restarting the whole system.
- Understand your entire capability set by calling `list_crews` and `list_tasks`. This shows you all available workflows and modular operations ready for immediate use.

## How It Works

The bottom line is: your AI client handles all the token management and state tracking between tools for you.

1. Subscribe to this MCP, then provide your CrewAI Agent Token found in the platform's dashboard.
2. Instruct your AI client to start a workflow by referencing an existing crew ID or asking it to create a new run using defined inputs.
3. Your agent executes the process, and you get back real-time updates on task completion, status changes, and final results.

## Frequently Asked Questions

**How do I start a new workflow using kickoff_crew?**
You initiate a run by calling `kickoff_crew` and providing a structured JSON payload that defines the goal. The agent then takes over, executing the entire multi-agent sequence automatically.

**What is get_run_status for?**
`get_run_status` pulls detailed cloud logging about an ongoing run. It’s how you figure out if a process failed because of resource limits or bad data, instead of just getting a vague 'Failed' message.

**Can I stop a running agent team using cancel_run?**
Yes. `cancel_run` sends an instant signal to hard-stop any active workflow. This is useful if the agents get stuck in a loop or start going off track.

**How do I check all available agent roles? Use list_agents.**
`list_agents` enumerates every role that can be part of your crew. This gives you a complete inventory and allows you to verify the rich details for each individual agent.

**What information does using get_crew provide about a crew's structure?**
It performs structural extraction of properties that drive the account logic. You get a complete map of all components, letting you verify exactly what data dictates the workflow before kicking off an autonomous run.

**How do I track asynchronous results after using list_webhooks?**
It identifies the exact validation criteria for async outcomes. This lets you monitor where a crew's final results go, even if they exit standard JSON boundaries and requires manual oversight.

**Before starting a run, what does list_tasks check?**
It runs an automated validation check that routes the explicit gateway history. You confirm all required tasks are properly routed and ready to execute before committing resources or triggering a crew.

**What specific rules can I see using get_agent?**
It enumerates the explicitly attached structured rules defining active billing constraints for that agent. You verify the precise operational guidelines governing its behavior and scope.

**Can my agent kickoff a new CrewAI workflow?**
Yes. Use the 'kickoff_crew' tool. Provide the Crew ID and a JSON object with the required inputs. The agent will activate the multi-agent processing immediately, returning a run ID for tracking.

**How do I monitor the progress of an active agent run?**
Use the 'get_run_status' tool with your Crew ID and Run ID. Your agent will grab the live execution state, showing you which agents are currently working and which tasks have been completed.

**Can I cancel a running crew via the agent?**
Absolutely. The 'cancel_run' tool dispatches an instant interrupt signal to the CrewAI platform, hard-stopping active LLM contexts and terminating the execution flow immediately.