# Cursor Cloud Agent MCP for AI Agents MCP

> Cursor Cloud Agent lets you spin up and manage autonomous coding agents from your favorite AI client. You can create agents with specific prompts, monitor their token usage, track their progress across repositories, and manage the entire lifecycle of your cloud-based coding tasks without touching a terminal.

## Overview
- **Category:** developer-tools
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_WJUsxIeBdLTUmOiGm9g0ZUKYn9WLxdIjkfcta731/mcp
- **Tags:** cloud-agents, ai-coding, code-generation, automated-workflows, cursor

## Description

This MCP lets you turn your AI client into a control plane for autonomous coding agents. Instead of manually managing prompts or watching progress bars, you can give your agent direct instructions to build, fix, or update code in your repositories. You'll be able to spin up new agents for specific tasks, like migrating a database or fixing a fleet of bugs, and then let them work in the background. You can see exactly what they're doing, how many tokens they're burning, and what files they've actually changed. It handles the heavy lifting of the agent lifecycle, so you can focus on reviewing the results. Since it's listed on the Vinkius catalog, you can plug it into your existing workflow and start delegating complex coding tasks to the cloud immediately.

## Tools

### unarchive_agent
Restore an archived Cursor cloud agent to your active list. This is useful for bringing back old configurations.

### archive_agent
Move a Cursor cloud agent to an archived state to keep your active list clean. This is a soft delete operation.

### cancel_run
Stop a running Cursor cloud agent task immediately. Use this if a run is taking too long or is no longer needed.

### create_agent
Set up a new Cursor cloud agent with a prompt, model choice, and repository links. It returns the initial run object.

### create_run
Start a new task for an existing Cursor cloud agent with a custom prompt. You can also override the mode or add images.

### get_agent
View the full configuration and status of a specific agent. Use this to check your current agent settings.

### get_agent_usage
Check the token usage statistics for a specific agent or run. This helps you monitor costs in real time.

### get_me
Identify the authenticated user and verify your API key. This confirms your account is correctly linked.

### get_run
See the detailed status and output of a specific agent run. It shows the git branch and completion status.

### list_agents
See all your agents with pagination and filters. You can also filter by PR URL or include archived agents.

### list_artifacts
See all the files an agent created or modified during its runs. This is perfect for auditing changes.

### list_runs
View a summary of all runs for a specific agent. Use this to see a history of completed and active tasks.

## Prompt Examples

**Prompt:** 
```
Create a cloud agent to fix the login bug in my repo.
```

**Response:** 
```
Creating a cloud agent... Done! Agent `agent-001` has been created with the prompt 'Fix the login bug in the repository' and is now running. The initial run `run-001` has started. You can check its status with `get_run`. Would you like me to enable autoCreatePR so the agent opens a pull request when it finishes?
```

**Prompt:** 
```
Show me how much the last run cost in tokens.
```

**Response:** 
```
Checking token usage for the last run... 

**Run Summary:**
- **Run ID:** `run-008`
- **Input Tokens:** 4,500
- **Output Tokens:** 1,200
- **Cache Tokens:** 800
- **Total:** 6,500 tokens

Would you like me to check the usage for any other specific runs?
```

**Prompt:** 
```
List all my active agents.
```

**Response:** 
```
Fetching your agents... Found 3 active agents:

| Agent Name | ID | Status |
| :--- | :--- | :--- |
| **README Agent** | `agent-001` | `active` |
| **Bug Fixer** | `agent-002` | `active` |
| **Doc Generator** | `agent-003` | `active` |

Would you like to see the details for a specific one?
```

## Capabilities

### Spin up new coding agents
Create autonomous agents with custom prompts and repository access.

### Track live progress
Monitor the status and duration of every running agent task.

### Monitor token costs
View detailed token usage for specific agents or individual runs.

### Discover file changes
See a complete list of artifacts produced by your agents.

### Archive and restore agents
Manage your active agent list by soft deleting or restoring entries.

### Stop runaway tasks
Cancel any running agent process instantly if it goes off track.

## Use Cases

### Automating library updates across multiple repos
A developer needs to update a core library in 20 different repositories. They use create_agent with a list of repo URLs to spin up an agent that handles the updates across the entire fleet.

### Auditing results of a bug fix
An engineer wants to see exactly what a cloud agent changed during a bug fix. They use list_artifacts to see every file modified and verify the changes before merging.

### Monitoring team token spend
A platform lead needs to see the cost of autonomous coding tasks. They use get_agent_usage to pull token statistics and optimize the team's cloud budget.

### Managing a cluttered agent list
A user has dozens of old agents from previous projects. They use archive_agent to clean up their workspace while keeping the configurations available for later use.

## Benefits

- Save time by using create_agent to delegate multi-file refactors to the cloud.
- Keep your costs in check by using get_agent_usage to monitor token consumption.
- Stay organized by using archive_agent to hide old tasks from your active list.
- Get instant visibility into results with list_artifacts to see every file changed.
- Prevent runaway costs by using cancel_run to stop tasks that aren't behaving.
- Simplify your workflow by using create_run to trigger tasks with specific prompts.

## How It Works

The bottom line is you get a command center for cloud-based autonomous coding.

1. Get your Cursor API key from the dashboard.
2. Connect this MCP to your AI client and enter your key.
3. Start telling your agent to create and run cloud tasks.

## Frequently Asked Questions

**How do I get my Cursor API key?**
Go to the **Cursor Dashboard → API Keys** section to create or manage your API key. The key starts with `crsr_` and can be either a user API key or a service account API key. Copy it and paste it into the API key field in the setup wizard. The key is sent as a Bearer token in the Authorization header for all API requests.

**What are Cursor cloud agents?**
Cloud agents are autonomous coding agents that run in Cursor's managed environment. You give them a prompt describing what you want (e.g. 'Add a README file to this repo'), connect one or more repositories, and the agent works autonomously — reading code, making changes, and optionally creating pull requests. You can track run status, view results, and manage the agent lifecycle through the API.

**Can cloud agents automatically create pull requests?**
Yes! When creating an agent, set the `autoCreatePR` flag to `true` and the agent will automatically create a pull request when it finishes its work. You can also filter agents by PR URL using the `pr_url` parameter in the `list_agents` tool to find agents associated with a specific PR.

**Which models are supported by cloud agents?**
Cursor cloud agents support multiple AI models including **gpt-4.1**, **claude-sonnet-4-20250514**, and **gemini-2.5-pro**. You can specify the model when creating an agent using the `model_id` parameter. If no model is specified, Cursor uses its default model. The model determines which AI processes your agent's prompts and generates code changes.

**How do I track the status of a run?**
Use the `get_run` tool with the agent ID and run ID to get the full status including the current state (running, completed, cancelled), duration in milliseconds, the result output, and git branch information. You can also use `list_runs` to see all runs for an agent. To stop a long-running run, use `cancel_run` — this is a terminal operation that cannot be undone.

**Can I configure MCP servers for my agent runs?**
Yes. When creating a run with the `create_run` tool, you can pass an `mcp_servers_json` parameter containing a JSON array of MCP server configurations. This allows your cloud agent to access external tools and resources during the run, extending its capabilities beyond the default set of tools.

**Are there rate limits on the Cloud Agents API?**
Yes, the Cursor Cloud Agents API enforces standard rate limiting. If you exceed the rate limit, the API returns an error and the engine surfaces the error message. For high-volume usage, consider spacing out requests and using pagination (limit and cursor parameters) when listing agents and runs. The `get_agent_usage` tool helps you monitor token consumption to stay within your plan's limits.