Sign in Book a demo
Back to Tools
Developer Tools API Key
Build Your Agent View Documentation
cursor-agents logo

Cursor Agents MCP Tools for AI Agents

Let an agent launch Cursor cloud agents, follow runs, send follow-up prompts, download artifacts, and manage agent lifecycles.

Available Tools

16 tools available in this integration

CursorAgents.ArchiveAgent

Archive a cloud agent so it stops accepting new runs (reversible).

CursorAgents.CancelRun

Cancel an active run; cancelling an already-terminal run returns an error.

CursorAgents.DeleteAgent

Permanently delete a cloud agent.

CursorAgents.DownloadArtifact

Get a time-limited download link for one uploaded artifact file.

CursorAgents.GetAgent

Get a cloud agent's configuration and latest run pointer.

CursorAgents.GetAgentUsage

Get token usage for an agent, summed and broken down per run.

CursorAgents.GetRun

Get a run's current status, and its result, branches, and PR once terminal.

CursorAgents.LaunchAgent

Launch a Cursor cloud agent on a repository or named environment.

CursorAgents.ListAgents

List your cloud agents, newest first.

CursorAgents.ListArtifacts

List the artifact files a cloud agent explicitly uploaded.

CursorAgents.ListModels

List the LLM models available to launch a cloud agent with.

CursorAgents.ListRepositories

List every GitHub repository Cursor can reach, as repository urls.

CursorAgents.ListRuns

List an agent's runs, newest first.

CursorAgents.SendFollowupRun

Send a follow-up prompt to an existing agent, starting a new run.

CursorAgents.UnarchiveAgent

Restore an archived cloud agent to active.

CursorAgents.WhoAmI

Return the Cursor account the API key authenticates as.

Working directly against the raw API? 7 more tools in the Cursor Agents API server →

Why agent-optimized tools matter

Built for intent, not API schemas

Ask the agent to "implement this issue in the matching repository and open a pull request." Arcade helps it use the right Cursor Agents tools without guessing repository URLs, agent IDs, or run IDs.

Up to 100x fewer tokens

Cursor Agents reads return focused agent, run, repository, and artifact metadata; full artifact files are fetched only when needed. The agent avoids loading entire run histories or files into the model.

Complete the workflow end to end

Find a reachable repository, launch an agent, inspect its run, send a follow-up, and download its artifact through one toolkit designed around the complete cloud-agent task.

Make actions predictable and controlled

Arcade tools return structured results and useful errors across users and runs. Teams can apply scope restrictions, redaction, and approval policies so agents follow the same controls every time.

Securing Cursor Agents

The more capabilities agents get, the more useful they are. However, more capabilities bring more risks of undesired effects such as data loss and exfiltration.

This is why Arcade provides you with contextual rules that dictate how and when a tool is allowed to run. Arcade’s contextual access lets you govern tool visibility and behavior at every stage of execution and control who can see a tool, what inputs are allowed, and what comes back.

Learn about Contextual Access Policies

For Cursor Agents, you can implement some of these policies:

Access when tools are listed for a user
  • Hide CursorAgents.DeleteAgent from agents unless the roles your IDP marks as platform administrators are active, so ordinary automation cannot permanently remove a cloud agent.
  • Restrict CursorAgents.ArchiveAgent to owners of the affected agent, so a routine coding agent cannot stop another team's agent from accepting new runs.
  • Deny CursorAgents.UnarchiveAgent to agents outside your release-operations role, so an archived agent cannot resume work without an authorized operator.
Pre-execution before each tool call
  • Require human approval before CursorAgents.LaunchAgent runs against a production repository or named environment, so an agent cannot start code changes in production unprompted.
  • Block CursorAgents.CancelRun for runs owned by another team or marked release-critical, so an agent cannot interrupt a deployment or discard another team's active work.
  • Require human approval before CursorAgents.SendFollowupRun sends a prompt that requests changes to a protected branch, so follow-up automation cannot direct production code changes without review.
Post-execution after the tool returns
  • Deny the output of CursorAgents.DownloadArtifact for artifacts from production repositories, so the model cannot receive time-limited links to private build files or generated credentials.
  • Redact secrets, access tokens, and customer data from the result and pull-request fields returned by CursorAgents.GetRun before they reach the model.
  • Strip private repository URLs from CursorAgents.ListRepositories results for agents without your repository-discovery role, so the model cannot map repositories it is not authorized to inspect.

How to use Cursor Agents with your agent

Configure one shared API key, connect your MCP client, and give an agent an authenticated path to launch and monitor cloud coding runs.

Your questions, answered

A Cursor Agents MCP server exposes cloud-agent capabilities as structured tools an AI agent can call through the Model Context Protocol. An agent can launch runs on reachable repositories, monitor results, send follow-ups, and retrieve uploaded artifacts.

Cursor Agents exposes an API for operating cloud agents rather than a first-party MCP server. Arcade provides the MCP gateway and adds shared-key credential brokering, approval workflows, redaction, and tool access controls.

Arcade agents can list reachable repositories and models, launch and monitor cloud-agent runs, send follow-up prompts, cancel active runs, inspect branches and pull requests, view usage, manage agent state, and list or download uploaded artifacts. They cannot merge pull requests because no merge action is provided.

Arcade uses the Cursor API key or secret configured for the integration. That credential determines which Cursor account, repositories, environments, models, and agent operations the calls can reach; Arcade does not request a separate per-user OAuth grant.

No. Cursor Agents uses one shared API key or secret configured once for the integration, rather than having every user connect an individual account. Arcade brokers that credential and does not pass it to the model.

Yes. Contextual Access policies can require human approval before consequential actions such as launching a run, canceling an active run, sending a follow-up, archiving an agent, or permanently deleting one. The call proceeds only after the policy's conditions are satisfied.

Arcade proxies Cursor Agents API calls and does not persist your content as part of normal tool execution. The API key or secret is brokered and stored encrypted at rest, and the model never receives it.

Any framework or client that can connect to Arcade's MCP gateway or tool APIs works, including LangChain, OpenAI Agents, CrewAI, Claude Desktop, Claude Code, Cursor, Visual Studio Code, Microsoft Copilot Studio, and GitHub Copilot.

Arcade refreshes access while the configured Cursor credential remains valid. If the key or secret is revoked, rotated, or can no longer be used, calls stop until the credential is updated or reconnected.

Cursor Agents API limits and account or organization quotas still apply to calls made through Arcade. Specific request, concurrency, token, and run limits depend on the Cursor plan and API credential in use.

Ready to actually ship your agent?

Connect your agent to Cursor Agents with a shared API key, agent-optimized tools and approval controls for consequential actions.

Build Your Agent Read the Cursor Agents Quickstart