Configure MCP

Aiden MCP lets you use Aiden from tools that speak Model Context Protocol (MCP), such as Cursor, VS Code, Claude Desktop, Windsurf, or Kiro. You stay in the editor. Aiden still runs as you, inside the workspaces your account can access.

Open the profile avatar menu, then click Configure MCP.

Available for roles: Admin Workspace Admin Workspace User

Scope: Account

Profile Menu

You need a personal access token before a client can connect. Treat that token like a password. Do not commit a live token to a shared repository.

What you connect to

One MCP URL serves every Aiden capability available to your token:

Aiden platform tools (aiden__…): chat with an agent, search runbooks, run and design workflows, and answer approvals or questions that come back from a run.
App tools (today, Aiden for SRE as sre__…): list and sync alerts, start investigations, and run discovery in a workspace.

The URL is Streamable HTTP. It is usually https://YOUR_AIDEN_HOST/mcp. The Configure MCP dialog always shows the correct host for your tenant, including self-hosted and Private SaaS.

Calls use your identity. Data is limited to workspaces you can open in Aiden. If an app is not enabled in the workspace you selected, the call fails with a plain-English error instead of mixing in another workspace's data.

Connect from the Aiden UI

The fastest path is the Configure MCP dialog.

Dialog title: Configure MCP.

Intro copy: Configure MCP (Model Context Protocol) by adding the following configuration to your MCP settings file.

A note reminds you to replace PERSONAL_ACCESS_TOKEN with your StackGen personal access token.

Create a personal access token if you do not already have one.
Open Configure MCP from the account menu (profile avatar).
Click Copy MCP configuration to copy the JSON snippet.
Paste it into your MCP client's settings file, then replace PERSONAL_ACCESS_TOKEN with the token secret.
Or use a one-click deep link when it is available:
- Add to Cursor
- Add to VS Code
- Add to Kiro
If you still need a token, click Open Personal Access Tokens in the dialog.
Click Close when finished.

After the client reloads MCP servers, you should see an Aiden server and a list of tools whose names start with aiden__ and, when SRE is available, sre__.

MCP configuration

Paste this shape if you configure the client by hand. Replace the host with the URL from Configure MCP, and replace the token placeholder.

{
  "mcpServers": {
    "aiden": {
      "url": "https://YOUR_AIDEN_HOST/mcp",
      "headers": {
        "Authorization": "Bearer PERSONAL_ACCESS_TOKEN"
      }
    }
  }
}

Optional: add "X-MCP-Toolsets": "core" or "sre" under headers to limit which tools the client lists. See Toolsets. Omit the header if you want both.

Cursor

Open Settings → Cursor Settings → Tools & MCP.
Choose New MCP Server, or edit ~/.cursor/mcp.json.
Paste the JSON above.
Save. Confirm Aiden appears in the MCP tools list and is enabled.

Ask Cursor something that needs Aiden (for example, "List my Aiden workflows" or "List firing alerts in my SRE workspace"). Cursor should call an aiden__ or sre__ tool rather than guessing.

VS Code

Open MCP settings and add a server with the same url and Authorization header.
Use Add to VS Code from the Aiden dialog when you want the deep link to prefill the snippet.

Claude Desktop

Claude Desktop often needs a small local helper for remote Streamable HTTP:

{
  "mcpServers": {
    "aiden": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://YOUR_AIDEN_HOST/mcp",
        "--header",
        "Authorization: Bearer ${APIKEY}"
      ],
      "env": {
        "APIKEY": "PERSONAL_ACCESS_TOKEN"
      }
    }
  }
}

Restart Claude Desktop after you save claude_desktop_config.json.

Windsurf and other MCP clients

Point the client at https://YOUR_AIDEN_HOST/mcp (Windsurf uses serverUrl in some versions). Send Authorization: Bearer <token> on every request. Any MCP client that supports Streamable HTTP and custom headers can connect the same way.

Toolsets

By default the client sees every tool source your token can use. Omit X-MCP-Toolsets when you want that full list. Set the header to one value when you want to narrow it.

Header value	What the client lists
(omit or leave empty)	Aiden platform tools and SRE tools together
`core`	Aiden platform tools only (`aiden__…`): chat, runbooks, and workflows
`sre`	Aiden for SRE tools only (`sre__…`): alerts, investigations, and discovery

Example (core only):

{
  "mcpServers": {
    "aiden": {
      "url": "https://YOUR_AIDEN_HOST/mcp",
      "headers": {
        "Authorization": "Bearer PERSONAL_ACCESS_TOKEN",
        "X-MCP-Toolsets": "core"
      }
    }
  }
}

A name that is not available in your environment adds no tools.

You can keep more than one MCP server entry (for example one named aiden-core and one named aiden-sre) if you want separate tool lists in the same client.

Workspaces

Aiden is workspace-first: Organization → Workspace → Apps. Integrations, alerts, and workflows belong to a workspace. Each tool call selects that workspace with stackgen_workspace_id.

Account	What happens
You can access one workspace	Aiden scopes calls to that workspace. You do not have to pass an ID.
You can access several workspaces	`stackgen_workspace_id` is required. Tool schemas list the IDs (and names) you can use.

Ask the client which workspace to use the first time, then keep that ID until you ask it to switch. Switching does not require a new MCP connection or a new token.

If the ID is missing (and you have more than one workspace), or if it is not yours, the tool returns an error that lists the workspaces available to the token.

Apps are enabled per workspace in Workspace Settings → Apps. The tool list stays the same when you switch workspaces. If SRE is not installed or configured in the workspace you picked, the SRE call fails with a message that names that workspace.

Create and manage workspaces in Organization Settings → Workspaces.

Tools

Names on the wire are <source>__<tool>. The client must call the namespaced name.

Aiden platform (`aiden__`)

These tools are present when the core toolset is included (or when you omit X-MCP-Toolsets).

Tool	What it does
`aiden__chat_with_agent`	Send a message to an Aiden agent and wait for the turn. Optional agent name and session id. May return a completed answer, or pause for approval or a clarifying question.
`aiden__search_runbooks`	Search approved runbooks by natural-language query.
`aiden__list_workflows`	List workflows you can see (name, domain, version, status).
`aiden__run_workflow`	Start an approved workflow by name and wait for the same kind of result as chat.
`aiden__propose_workflow`	Validate a workflow design without publishing it. The client should show you the proposal and wait for an explicit yes or no.
`aiden__create_workflow`	Publish a new workflow after you have accepted a create proposal.
`aiden__update_workflow`	Publish a new version of an existing workflow after you have accepted an update proposal.
`aiden__resolve_approval`	Approve or refuse a pending human-in-the-loop step from a prior chat or workflow run, then continue.
`aiden__respond_clarification`	Answer a pending question from a prior run, then continue. Do not start a new `chat_with_agent` turn to answer; that leaves the original ask blocked.

Workflow design is two steps on purpose: propose, then create or update only after you confirm. Do not ask the client to publish in the same turn as the proposal.

Aiden for SRE (`sre__`)

These tools are present when the sre toolset is included (or when you omit the header). They operate on the selected workspace. Enable Aiden SRE for that workspace in Apps. See Aiden for SRE for the same work in the web app.

Tool	What it does
`sre__sre_list_alerts`	List ingested alerts.
`sre__sre_get_alert`	Get one alert by id.
`sre__sre_sync_alerts`	Start or poll an alert sync from connected sources.
`sre__sre_list_investigations`	List investigations.
`sre__sre_get_investigation`	Get one investigation.
`sre__sre_start_investigation`	Start an investigation (typically from an alert).
`sre__sre_start_discovery`	Start a discovery scan of connected integrations.
`sre__sre_get_discovery`	Get discovery run status.
`sre__sre_list_discovery_entities`	List entities found by discovery.
`sre__sre_get_discovery_insights`	Get insights from a discovery run.

SRE tools in MCP are the same class of work you do in the SRE app: inventory, investigations, and discovery. They are not a back door to internal agent writebacks.

After sre__sre_start_investigation, continue the investigation thread with aiden__chat_with_agent when the result includes a session id.

Try it

Once the client shows Aiden tools:

If you have more than one workspace, tell the client which one to use.
Ask it to list workflows (aiden__list_workflows) or, with SRE enabled, to list alerts (sre__sre_list_alerts).
Confirm the results match that workspace in the Aiden UI.

If tools never appear, check that the token is not expired, that Authorization uses Bearer plus the secret, and that the URL matches Configure MCP for your tenant (path /mcp).

What you connect to​

Connect from the Aiden UI​

MCP configuration​

Cursor​

VS Code​

Claude Desktop​

Windsurf and other MCP clients​

Toolsets​

Workspaces​

Tools​

Aiden platform (aiden__)​

Aiden for SRE (sre__)​

Try it​