# Connect your assistant

Source: https://pilot.braike.com/en/docs/brancher-son-assistant

Add Pilot to Claude, Claude Code, ChatGPT, Codex, Cursor, VS Code or any MCP client, by hand or with the Pilot CLI, authorize access, and remove it.

Add Pilot as a remote MCP server, at `https://app.pilot.braike.com/mcp`. The connection uses OAuth: on first use, your assistant opens a Pilot page where you choose the workspace to share and what the assistant may do. No key to copy.

| Setting | Value |
| --- | --- |
| Server address | `https://app.pilot.braike.com/mcp` |
| Transport | Streamable HTTP |
| Authentication | OAuth 2.1 with PKCE and automatic client registration; access key for tools that cannot sign in on their own |
| Access level | Read-only |

<Callout title="Your workspace address">
Each workspace console also gives an address specific to the workspace, `https://app.pilot.braike.com/mcp/<workspace id>`. It locks the authorization to that workspace: handy for an agency that connects one workspace per client. With the universal address, you choose the workspace when you authorize access.
</Callout>

## With the Pilot CLI [#cli]



From a terminal, one command makes most of this page's settings for you:

```bash title="Terminal"
npx @braike/pilot setup
```

It finds the assistants installed on your computer (Claude Desktop, Claude Code, Cursor, VS Code, Windsurf, Codex, Gemini CLI) and registers Pilot in them, with a dated copy of each configuration before changing it. `--client <name>` targets a single assistant, `--dry-run` shows the change without writing anything. You then authorize access on the same screen, described below. Each section gives its assistant's command; every command is on [The Pilot CLI](/en/docs/cli).

## The authorization screen [#autorisation]

On the first call, your assistant opens the **"… is requesting access to Pilot"** page on `app.pilot.braike.com`. Sign in to Pilot if needed, then:

1. **Shared workspace**: choose the workspace the assistant may read. With a workspace address, it is already chosen.
2. **What the assistant can do**: **Read**. In a Pilot MCP workspace, it is the only level offered: the screen says under the other levels that your plan is read-only.
3. Click **Allow read access**. Pilot sends you back to your assistant.

The application name shown is the one it declares: Pilot says so when it cannot verify it. Deny if you did not start the connection yourself. If your assistant accesses are all used, the screen says so: remove one from **Manage AI accesses** before authorizing the new one.

## Claude (claude.ai and Claude Desktop) [#claude]

A connector added on claude.ai also works in Claude Desktop and in the mobile app: it belongs to your Claude account.

<Steps>
<Step>

**Add the connector.** In Claude, open **Customize** then **Connectors**, click **+ Add** then **Add custom connector**.

</Step>
<Step>

**Name and address.** Name it `Pilot`, paste `https://app.pilot.braike.com/mcp` and click **Continue**.

</Step>
<Step>

**Authentication.** Keep OAuth. Under **OAuth client**, choose **Register automatically**: Pilot registers Claude's client itself. Click **Add**.

</Step>
<Step>

**Authorize.** Connect the connector, then approve Pilot's authorization page.

</Step>
<Step>

**Use it.** In a conversation, open the **+** button, then **Connectors**, and turn Pilot on.

</Step>
</Steps>

- **Team and Enterprise plans**: an owner of the organization first adds the connector in **Organization settings**, **Connectors**, **Add**, **Custom**, **Web**. Each member then connects it from **Customize**, **Connectors**.
- **Free plan**: Claude limits the free plan to one custom connector.
- **Remove**: **Customize**, **Connectors**, then **Remove** or the connector's **…** menu.

**Claude Desktop, with the [Pilot CLI](#cli).** These commands register Pilot in Claude Desktop's configuration as a local server, connected to Pilot through the `pilot mcp` bridge and signed in by `pilot login`. Keep either the connector or this local server, not both, so as not to see Pilot twice.

```bash title="Terminal"
npx @braike/pilot login
npx @braike/pilot setup --client claude-desktop
```

Source: [Getting started with custom connectors using remote MCP](https://support.claude.com/en/articles/11175166-getting-started-with-custom-connectors-using-remote-mcp) (Anthropic).

## Claude Code [#claude-code]

Add the server, then sign in from Claude Code:

```bash title="Terminal"
claude mcp add --transport http pilot https://app.pilot.braike.com/mcp
```

Add `--scope user` to get Pilot in all your projects. Then start Claude Code and type `/mcp`: sign-in opens in your browser. You can also run `claude mcp login pilot` from the terminal.

To share a project's configuration, the `.mcp.json` file at its root:

```json title=".mcp.json"
{
  "mcpServers": {
    "pilot": {
      "type": "http",
      "url": "https://app.pilot.braike.com/mcp"
    }
  }
}
```

- **Sign out**: `claude mcp logout pilot`, or **Clear authentication** in `/mcp`.
- **Remove**: `claude mcp remove pilot`, which also deletes the tokens kept by Claude Code.

**With the [Pilot CLI](#cli)**, one command makes this setting, for all your projects; then sign in with `/mcp`:

```bash title="Terminal"
npx @braike/pilot setup --client claude-code
```

Source: [Connect Claude Code to tools via MCP](https://code.claude.com/docs/en/mcp) (Anthropic).

## ChatGPT [#chatgpt]

ChatGPT adds an MCP server as a plugin.

<Steps>
<Step>

Open [chatgpt.com/plugins](https://chatgpt.com/plugins), click **+** then **Add custom MCP server**.

</Step>
<Step>

Give a name (`Pilot`) and a description. Under **Connection**, paste `https://app.pilot.braike.com/mcp`.

</Step>
<Step>

Choose OAuth authentication, read the warning then click **I understand and want to continue**, and finally **Create as a plugin**. ChatGPT shows the tools Pilot serves.

</Step>
<Step>

Install and connect the plugin, approve Pilot's authorization page, then, in a conversation, type `@` and choose Pilot.

</Step>
</Steps>

- **Organization accounts**: your ChatGPT workspace policies apply. An admin may have to allow custom MCP servers.
- **Remove**: open the plugin and choose **Uninstall plugin**, then disconnect Pilot where it was connected.

The [Pilot CLI](#cli) does not set up ChatGPT in the browser; for the desktop app, see [Codex and the ChatGPT desktop app](#codex).

Sources: [Connect and test your plugin](https://developers.openai.com/plugins/deploy/connect-chatgpt) and [Plugins](https://learn.chatgpt.com/docs/plugins) (OpenAI).

## Codex and the ChatGPT desktop app [#codex]

Codex CLI, its editor extension and the ChatGPT desktop app share the same configuration.

```bash title="Terminal"
codex mcp add pilot --url https://app.pilot.braike.com/mcp
codex mcp login pilot
```

Or in `~/.codex/config.toml`:

```toml title="~/.codex/config.toml"
[mcp_servers.pilot]
url = "https://app.pilot.braike.com/mcp"
```

In the desktop app: **Settings**, **MCP servers**, **Add server**, choose **Streamable HTTP**, paste the address, save, restart, then **Authenticate**.

**With the [Pilot CLI](#cli)**, one command makes this setting; then sign in with `codex mcp login pilot`:

```bash title="Terminal"
npx @braike/pilot setup --client codex
```

Source: [Model Context Protocol](https://learn.chatgpt.com/docs/extend/mcp) (OpenAI).

## Cursor [#cursor]

<BoutonInstallation client="cursor">Add Pilot to Cursor</BoutonInstallation>

The button opens Cursor with Pilot already set up. On first use, Cursor opens Pilot's authorization page. To set it up by hand, add Pilot to `~/.cursor/mcp.json` (all your projects) or `.cursor/mcp.json` (one project):

```json title="~/.cursor/mcp.json"
{
  "mcpServers": {
    "pilot": {
      "url": "https://app.pilot.braike.com/mcp"
    }
  }
}
```

- **Turn off**: in **Customize**, switch Pilot off without removing it.
- **Remove**: delete the `pilot` entry from the `mcp.json` file.

**With the [Pilot CLI](#cli)**, one command makes this setting, in `~/.cursor/mcp.json`:

```bash title="Terminal"
npx @braike/pilot setup --client cursor
```

Sources: [Model Context Protocol](https://cursor.com/docs/context/mcp) and [MCP install links](https://cursor.com/docs/context/mcp/install-links) (Cursor).

## VS Code [#vs-code]

<BoutonInstallation client="vscode">Add Pilot to VS Code</BoutonInstallation>

The button opens VS Code with Pilot already set up. To set it up by hand, run the **MCP: Add Server** command, choose **HTTP** and paste the address, or add Pilot to `.vscode/mcp.json`:

```json title=".vscode/mcp.json"
{
  "servers": {
    "pilot": {
      "type": "http",
      "url": "https://app.pilot.braike.com/mcp"
    }
  }
}
```

VS Code registers its client with Pilot automatically, then opens sign-in in your browser.

- **Manage access**: **Accounts** menu, **Manage Trusted MCP Servers**.
- **Stop or remove**: **MCP: List Servers** command, choose Pilot, then the action you need.

**With the [Pilot CLI](#cli)**, one command makes this setting, in your user profile (`--client vscode-insiders` for VS Code Insiders):

```bash title="Terminal"
npx @braike/pilot setup --client vscode
```

Sources: [Add and manage MCP servers in VS Code](https://code.visualstudio.com/docs/copilot/customization/mcp-servers) and [MCP developer guide](https://code.visualstudio.com/api/extension-guides/ai/mcp) (Microsoft).

## Any other MCP client [#autres]

Any client that speaks MCP over Streamable HTTP connects to `https://app.pilot.braike.com/mcp`.

- **With OAuth.** The server answers `401` with a `WWW-Authenticate` header that points to its protected resource metadata (`/.well-known/oauth-protected-resource`). The client finds the authorization server there (`/.well-known/oauth-authorization-server`), registers (`/oauth/register`), then runs the flow with PKCE `S256`. The challenge asks for the `mcp:viewer mcp:analyst` scope, the Read level.
- **Without OAuth, with an access key.** A workspace admin creates a key in the console, **For developers** block. It starts with `ulys_` and is shown only once. The client sends it in the `Authorization` header:

```json title="Example configuration"
{
  "mcpServers": {
    "pilot": {
      "url": "https://app.pilot.braike.com/mcp",
      "headers": {
        "Authorization": "Bearer ulys_example_to_replace"
      }
    }
  }
}
```

A key belongs to one workspace: with the universal address, it opens its workspace. Keep it out of your code repositories and prefer an environment variable.

**A client that only speaks stdio** runs Pilot as a local program, through the [Pilot CLI](#cli) bridge, `pilot mcp`. Declare it in the client's configuration:

```json title="stdio client configuration"
{
  "mcpServers": {
    "pilot": {
      "command": "npx",
      "args": ["-y", "@braike/pilot", "mcp"]
    }
  }
}
```

The bridge signs in with `npx @braike/pilot login`, or with an access key given in the `PILOT_API_KEY` variable; without a sign-in, it opens the sign-in in your browser by itself.

For any other client, `npx @braike/pilot setup --client generic` prints the configuration to copy. **Windsurf (Devin Desktop) and Gemini CLI** are also set up with the CLI; in Gemini CLI, then sign in with `/mcp auth pilot`:

```bash title="Terminal"
npx @braike/pilot setup --client windsurf
npx @braike/pilot setup --client gemini
```

## Remove an access [#retirer]

- **From Pilot**: on the workspace's **Claude & ChatGPT** page, **Active access** block, click **Remove**. A member removes their own accesses; an admin, all those of the workspace. The assistant can no longer query the workspace from its next call.
- **From the assistant**: remove the connector or the server, as shown for each client above.
- **From the terminal**: `npx @braike/pilot remove --client <name>` removes Pilot from an assistant's configuration, and `npx @braike/pilot logout` deletes the token kept by the CLI.
- **When someone leaves the workspace**, their assistants lose access on their next call, and their access keys are revoked on first use.