Cursor

Connect Cursor to Anlyon's MCP server so its agent calls your production APIs through governed actions, with OAuth sign-in or an API key.

Cursor’s agent can do production work, such as opening the issue, updating the deal or refunding the charge, but only with your API tokens in its reach, and nothing checks a call before it goes out.

Connect Cursor to Anlyon instead. Your workspace’s actions appear as tools. The agent names an action and passes input; Anlyon adds the credential at dispatch, so Cursor never holds one. A risky call waits for an approver before anything is sent, impact limits cap what calls can do, and every call leaves a receipt.

This covers calls routed through Anlyon. A call Cursor makes directly, with a token it holds, is not governed by Anlyon.

Connect Cursor with OAuth

Cursor connects to Anlyon’s hosted MCP server and signs you in with OAuth (“Login with Anlyon”). There is no key to paste.

{
  "mcpServers": {
    "anlyon": {
      "url": "https://api.anlyon.com/mcp"
    }
  }
}

Connect Cursor with an API key

Use a key where no browser sign-in is possible, or when the key’s scopes should define exactly what Cursor can do. Create it in the console under Settings → API keys with actions:read, actions:invoke and approvals:read (all in the Standard preset). Add approvals:write if the agent should call request_approval.

Read the key from the environment, so it never lands in a committed file:

{
  "mcpServers": {
    "anlyon": {
      "url": "https://api.anlyon.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:ANLYON_API_KEY}"
      }
    }
  }
}

Cursor resolves ${env:NAME} in url, headers, command, args and env. Set ANLYON_API_KEY in the environment Cursor starts from.

A key belongs to one environment, so list_workspaces and select_workspace do not apply.

Act as one of your users

To test what your product’s agent does for one of your users, in that user’s own connected accounts, add Anlyon-End-User. It works with an API key only:

{
  "mcpServers": {
    "anlyon-as-user": {
      "url": "https://api.anlyon.com/mcp",
      "headers": {
        "Authorization": "Bearer ${env:ANLYON_API_KEY}",
        "Anlyon-End-User": "user_123"
      }
    }
  }
}

See Act for one of your users.

Run the server as a local process

The npm package runs the same tools over stdio:

{
  "mcpServers": {
    "anlyon": {
      "command": "npx",
      "args": ["-y", "@anlyonhq/mcp-server"],
      "env": { "ANLYON_API_KEY": "${env:ANLYON_API_KEY}" }
    }
  }
}

Add "--end-user", "user_123" to args to act for one user.

Use the tools

With OAuth, Cursor sees only the tools the permissions you granted cover. See Tools for the full reference.

Call an action that needs approval

Ask the agent:

Set ticket T-1042 to priority high. If it needs approval, wait for the decision and tell me what happened.

1. The agent calls action_update-ticket-priority with { "ticketId": "T-1042", "priority": "high" }.
2. The action is gated, so nothing is sent. The tool answers Awaiting human approval. Call wait_for_approval with approvalId=apr_....
3. The agent calls wait_for_approval. An approver decides in the console, in Slack or from their own MCP connection.
4. The tool returns the approval with "status": "approved", who decided, and payload.invocationId. Anlyon has run the exact request that was reviewed. If it is still pending, the agent calls wait_for_approval again. If it is denied or expired, nothing was sent.

The outcome is on the invocation, in the console’s invocation log. An outcome of unknown means the request may have reached the destination: do not call the action again. See When the outcome is unknown.

Review approvals from Cursor

With Approve on your behalf granted, list_pending_approvals and decide_approval let you review from Cursor. Your decision is recorded against your name, with your reason as the note.

You can never decide an approval that your own agent requested, whether Cursor or any other app signed in as you, or a key you created. A teammate decides it. If nobody else in the environment can decide approvals, decide it yourself in the console or in Slack.

Connect one integration only

Each integration has its own MCP server with that integration’s actions plus check_approval and wait_for_approval:

{
  "mcpServers": {
    "anlyon-github": {
      "url": "https://api.anlyon.com/mcp/github"
    }
  }
}

See One integration’s MCP server for every address.

Tell Cursor how this project uses Anlyon

Add a rule file such as .cursor/rules/anlyon.mdc:

## Anlyon
- Production calls go through Anlyon actions, not direct API calls. Find them with the Anlyon `list_actions` tool and call one through its `action_<name>` tool.
- Never ask for, print or store a provider credential. Anlyon adds it when the call is sent.
- If an action needs approval, call `wait_for_approval` with the `apr_` id and report the decision.
- An invocation with status `unknown` may have taken effect. Do not retry it; tell me so I can reconcile.
- Docs: https://docs.anlyon.com/llms.txt

To set a project up to call Anlyon from its own code, paste the agent setup prompt into Cursor instead.

Fix connection errors

See Fix a refused connection or call for the full list.

Related

• MCP servers: the full reference
• Claude Code and Codex: the same server in other tools
• Actions: define what Cursor can call
• Approvals: policies and approvers