> ## Documentation Index
> Fetch the complete documentation index at: https://docs.exec.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Connect Your AI Tool

> Set up Exec MCP in Claude, ChatGPT, Cursor, or any assistant that supports MCP.

Everything you need is one URL, and it is the same for every assistant:

```text theme={null}
https://api.exec.com/mcp
```

There is nothing to switch on inside Exec. Your normal Exec login authorizes the connection, and your existing Exec permissions are what it gets. Sign-in is handled by Exec, so there is no API key to generate, paste, or rotate, and no client ID or secret to fill in. If a tool offers advanced OAuth fields, leave them blank.

***

## Find your tool

Each section below is self-contained, so you only need to read your own.

<CardGroup cols={3}>
  <Card title="Claude" href="#claude">
    Desktop and web
  </Card>

  <Card title="Claude Code" href="#claude-code">
    Terminal
  </Card>

  <Card title="ChatGPT" href="#chatgpt">
    Desktop and web
  </Card>

  <Card title="Codex" href="#codex">
    Terminal
  </Card>

  <Card title="Cursor" href="#cursor">
    Editor
  </Card>

  <Card title="Anything else" href="#any-other-mcp-client">
    Any MCP client
  </Card>
</CardGroup>

***

## Claude

The desktop app and claude.ai. Available on Free, Pro, Max, Team, and Enterprise, though Free allows only one custom connector in total.

<Steps>
  <Step title="Owner: add Exec to the organization">
    Only on Team and Enterprise, and only an Owner can do this. Go to **Organization settings > Connectors**, click **Add**, hover **Custom** and choose **Web**, then paste the URL and name it **Exec**.

    ```text theme={null}
    https://api.exec.com/mcp
    ```

    On an individual plan, skip this step.
  </Step>

  <Step title="Add or find Exec in your own connectors">
    Go to **Customize > Connectors**. On Team or Enterprise, Exec is already listed and shows as not connected. On an individual plan, click **+**, choose **Add custom connector**, paste the URL above, and click **Add**.
  </Step>

  <Step title="Sign in to Exec">
    Click **Connect**. A browser tab opens on an Exec page titled **Connect to Exec**. Enter your work email, then sign in with single sign-on or your Exec password.
  </Step>

  <Step title="Choose a workspace, if asked">
    Only if you belong to more than one Exec workspace. The connection is bound to whichever you pick.
  </Step>

  <Step title="Turn it on in your chat">
    In a conversation, click **+** at the lower left, open **Connectors**, and make sure Exec is on.
  </Step>

  <Step title="Check it worked">
    Ask:

    ```text theme={null}
    Show me my most recent roleplay sessions in Exec.
    ```

    Your own recent sessions should come back.
  </Step>
</Steps>

<Note>
  Claude has no way to edit a connector once it exists. If the URL or the name needs changing, remove it and add it again.
</Note>

***

## Claude Code

One command in your terminal:

<Steps>
  <Step title="Add the server">
    ```bash theme={null}
    claude mcp add --transport http exec https://api.exec.com/mcp
    ```

    This adds it for the current project. Add `--scope user` to make it available in all your projects, or `--scope project` to share it with your team through a checked-in `.mcp.json`.
  </Step>

  <Step title="Sign in to Exec">
    Run `/mcp` inside Claude Code, choose Exec, and follow the browser prompts. Your token is stored and refreshed automatically.

    You can also run `claude mcp login exec` directly.
  </Step>

  <Step title="Check it worked">
    ```text theme={null}
    Show me my most recent roleplay sessions in Exec.
    ```
  </Step>
</Steps>

***

## ChatGPT

Available on Plus, Pro, Business, Enterprise, and Education, but not on Free. Custom MCP servers live under **Plugins**, and they require Developer mode.

<Steps>
  <Step title="Turn on Developer mode">
    In ChatGPT, open **Settings > Security and login** and switch on **Developer mode**. Nothing below appears until you do.

    ChatGPT shows a broad caution here about connectors that can change or delete things. Exec is read-only apart from creating a roleplay scenario, which it shows you as a draft before publishing.

    On Business and Enterprise workspaces, Developer mode can be restricted by workspace policy, so you may need your ChatGPT admin here.
  </Step>

  <Step title="Create the connection">
    Go to **chatgpt.com/plugins** and click **+**. Give it a name and description, such as **Exec** and "Practice and performance data from our Exec workspace."
  </Step>

  <Step title="Point it at Exec">
    Under **Connection**, paste the URL, including the `/mcp` on the end:

    ```text theme={null}
    https://api.exec.com/mcp
    ```

    Create the connection, then review the tools it discovered. Your new app appears under **Drafts**.
  </Step>

  <Step title="Sign in to Exec">
    The same Exec sign-in page as everywhere else. Enter your work email, then sign in with single sign-on or your Exec password.
  </Step>

  <Step title="Enable it for a conversation">
    ChatGPT does not use it automatically. In a chat, open the **Plus** menu, choose **Developer mode**, and select Exec for that conversation.
  </Step>

  <Step title="Check it worked">
    ```text theme={null}
    Using the Exec connector, show me my most recent
    roleplay sessions.
    ```

    Name Exec in your first message, or ChatGPT may answer from general knowledge instead of reaching for the connector.
  </Step>
</Steps>

***

## Codex

The Codex CLI, the ChatGPT desktop app, and the Codex IDE extension share one configuration, so you set this up once.

<Steps>
  <Step title="Add the server">
    ```bash theme={null}
    codex mcp add exec --url https://api.exec.com/mcp
    ```

    The `--url` flag is what makes this a remote server rather than a local command.
  </Step>

  <Step title="Sign in to Exec">
    Sign-in does not happen automatically here. Run:

    ```bash theme={null}
    codex mcp login exec
    ```

    A browser opens on the Exec sign-in page. Add `--no-browser` if you would rather paste the URL yourself.
  </Step>

  <Step title="Check it worked">
    Run `codex mcp list` to confirm Exec is there, then ask:

    ```text theme={null}
    Show me my most recent roleplay sessions in Exec.
    ```

    Inside the Codex TUI, `/mcp` shows which servers are active.
  </Step>
</Steps>

**Editing the config file instead.** The command above writes to `~/.codex/config.toml`. You can add the same thing by hand:

```toml theme={null}
[mcp_servers.exec]
url = "https://api.exec.com/mcp"
```

Then run `codex mcp login exec` as above.

<Note>
  The ChatGPT desktop app and the IDE extension read this same file, but you need to restart them to pick up a change. Both also offer a settings screen: **MCP servers > Add server**, choose **Streamable HTTP**, paste the URL, then use the **Authenticate** action on the row.

  **ChatGPT on the web is different.** It does not read your local Codex configuration at all. There, use the [ChatGPT](#chatgpt) steps above instead.
</Note>

***

## Cursor

<Steps>
  <Step title="Add Exec to your MCP config">
    Create or edit `~/.cursor/mcp.json` to make Exec available everywhere, or `.cursor/mcp.json` in a project to keep it to that project:

    ```json theme={null}
    {
      "mcpServers": {
        "exec": {
          "url": "https://api.exec.com/mcp"
        }
      }
    }
    ```

    A remote server needs only `url`. The `type` field is for local servers.
  </Step>

  <Step title="Sign in to Exec">
    Open the **Customize** page in the sidebar, find Exec in the MCP list, and use the sign-in prompt on its row. A browser tab opens on the Exec sign-in page.
  </Step>

  <Step title="Check it worked">
    ```text theme={null}
    Show me my most recent roleplay sessions in Exec.
    ```

    If nothing happens, open the Output panel and select **MCP Logs**.
  </Step>
</Steps>

<Note>
  On Cursor Enterprise, admins can restrict which MCP servers run, under **Team Settings > MCP Configuration**. If Exec never appears, ask them to allowlist `https://api.exec.com/mcp`.
</Note>

***

## Any other MCP client

Exec speaks the standard Model Context Protocol, so anything supporting remote MCP servers over HTTP can connect. Paste the URL wherever your tool asks for a custom MCP server, then sign in.

```text theme={null}
https://api.exec.com/mcp
```

If your tool takes a JSON config file rather than a URL field, this is the same connection:

```json theme={null}
{
  "mcpServers": {
    "exec": {
      "type": "http",
      "url": "https://api.exec.com/mcp"
    }
  }
}
```

Your tool needs two things:

| Requirement                  | Detail                                                                                                    |
| :--------------------------- | :-------------------------------------------------------------------------------------------------------- |
| Remote MCP servers over HTTP | Exec is hosted. Tools that only launch servers locally need the bridge below.                             |
| Sign-in support              | Your assistant opens Exec's sign-in page and stores the result. Nearly every current client handles this. |

### Using a local config file

Two reasons to take this route: your client can only run an MCP server as a local process, or you are on a Team or Enterprise plan and would rather not wait for an owner to add the connector. A small bridge makes the remote server look local:

```json theme={null}
{
  "mcpServers": {
    "exec": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.exec.com/mcp"]
    }
  }
}
```

This needs Node.js 18 or newer, and the Exec sign-in appears the first time the connection is used. If sign-in gets stuck, deleting the `~/.mcp-auth` folder and restarting your client clears it.

<Note>
  This also sidesteps the connector list entirely, which makes it a way to evaluate Exec before your IT team has approved anything. That does mean it sits outside whatever governance your company has around AI tool connectors, so move to the approved route once somebody can approve it.
</Note>

### In-house assistants and agents

A connection is always scoped to one person and one workspace. There is no service account, and access is exactly the signed-in person's Exec permissions, so an agent acting for a team sees only what the person who authorized it can see.

If you already hold an Exec API key it can be used as a bearer token instead of signing in, which suits an unattended service. Treat it carefully: it acts with workspace admin access and does not expire. For anything a person drives, prefer the normal sign-in. To build directly against Exec rather than through an assistant, see the [API Reference](/api-reference/overview).

***

## Your assistant will ask before it uses Exec

The first time it reaches for Exec, most assistants ask your permission, usually offering something like ask every time, always allow, or block. This is your assistant's own setting rather than Exec's.

Always allow is the usual choice for reading your own data. If your assistant later says it cannot see your Exec data even though the connector shows as connected, check whether the capability got blocked here.

***

## Staying connected, and disconnecting

**Staying connected.** It refreshes quietly. In normal use you should not have to sign in again for about a month.

**Reconnecting is often silent.** If you already hold a live authorization and reconnect, you may go straight through with no sign-in and no consent screen, reusing the workspace you picked originally. That is expected. To change workspace, disconnect first.

**Disconnecting.** Remove the connector in your assistant. That ends the whole authorization, not just the current session.

<Note>
  There is no MCP screen in Exec, so disconnecting happens on your assistant's side. For offboarding you do not need to touch anyone's assistant: deactivating someone in Exec, or removing them from the workspace, cuts their access on their next request.
</Note>

***

## Common problems

<Warning>
  **An empty answer usually means the sign-in did not finish.** The connection still looks present, so your assistant reports an empty workspace rather than a problem. If an answer you expect comes back empty, reconnect before concluding there is no data.
</Warning>

<AccordionGroup>
  <Accordion title="Exec is not in my connectors list">
    On Free, Pro, or Max, add it yourself as a custom connector using the URL above. On a Team or Enterprise plan, an owner has to add Exec for the organization before it appears for anyone else. In ChatGPT, check that Developer mode is on.
  </Accordion>

  <Accordion title="It says connected but every answer is empty">
    The sign-in almost certainly did not complete. Disconnect, reconnect, and make sure you reach the Exec sign-in page and authorize. An unfinished sign-in fails quietly rather than showing an error. If you have several tools connected, it can also mean your assistant used a different one, so try starting with "Using the Exec MCP, ...".
  </Accordion>

  <Accordion title="My assistant ignores Exec and answers from general knowledge">
    Name it explicitly: "Using the Exec MCP, ...". Common with ChatGPT. Also check the connector is switched on for that conversation.
  </Accordion>

  <Accordion title="I cannot sign in">
    It is the same sign-in as the Exec app, including the lockout after repeated failed attempts, so somebody locked out of Exec is locked out of connecting until that clears. Reset your password in Exec if needed. If single sign-on sends you back with an error, your email may not be attached to that workspace.
  </Accordion>

  <Accordion title="I picked the wrong workspace">
    Disconnect the connector and connect again, choosing the right one. The connection is bound to whichever you picked.
  </Accordion>

  <Accordion title="An error about the authorization already being completed">
    Two sign-ins raced each other and one won. Harmless. Reconnect.
  </Accordion>

  <Accordion title="It says it does not have permission">
    Either the capability is blocked in your assistant's own permission settings, or you genuinely do not have access to that data in Exec. Skill and scenario analytics, for example, are limited to admins and group admins. See [What the AI can see](/mcp/what-the-ai-can-see).
  </Accordion>

  <Accordion title="Charts and dashboards do not appear">
    Charts need an assistant that can display interactive panels. In a text-only assistant you get the numbers instead, which is not a failure. See [Limits](/mcp/limits).
  </Accordion>
</AccordionGroup>

[Full troubleshooting guide](/mcp/troubleshooting).

***

## Next

<CardGroup cols={2}>
  <Card title="Prompts and reliable answers" href="/mcp/prompts-and-answers">
    Prompts by role, ready to copy
  </Card>

  <Card title="Managing your team" href="/mcp/for-team-leads">
    The video walkthrough, if you run a team
  </Card>
</CardGroup>