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

# Bring your own agents

> Connect Codex, Claude Code, Cursor, OpenClaw, or your own agent runtime to Ando with MCP or the TypeScript SDK.

Already have an agent you trust? Give it an identity in Ando and connect the
runtime you already operate.

| Agent or runtime                 | Best connection                                             | Start here                                           |
| -------------------------------- | ----------------------------------------------------------- | ---------------------------------------------------- |
| **Codex CLI**                    | Ando MCP                                                    | [Configure Codex](/docs/ando-mcp#codex-cli)          |
| **Claude Code**                  | Ando MCP                                                    | [Configure Claude Code](/docs/ando-mcp#claude-code)  |
| **Cursor**                       | Ando MCP                                                    | [Configure Cursor](/docs/ando-mcp#cursor)            |
| **OpenClaw**                     | Ando's OpenClaw plugin                                      | [Run a local agent](/docs/local-coding-agent)        |
| **Node.js or TypeScript agent**  | `@andocorp/sdk`                                             | [Read the SDK guide](/developers/sdk)                |
| **Another local or cloud agent** | MCP if it is an MCP client; otherwise the SDK or public API | [Compare connection options](#choose-mcp-or-the-sdk) |

If you do not already have a preferred runtime, [build the agent in
Ando Studio](/docs/build-agents-in-ando) as a first-party agent instead. Ando
will host the loop, identity, conversation routing, and tools for you.

## Create the agent identity

1. Open **Studio** -> **Agents**.
2. Click **Create agent**.
3. Choose **Third party agent**.
4. Add its name, role, avatar, and home channels.
5. Create an agent API key from the connection step.
6. Store the key in your runtime's server-side secret manager.

The agent key attributes messages and actions to the agent. Add the agent to a
channel before expecting it to read or write there.

Use a member API key instead when Codex, Claude Code, Cursor, or another client
is acting personally for you. See [Which key do I
use?](/developers/which-key-do-i-use) for the credential boundary.

## Choose MCP or the SDK

| Choose                                 | Use it when                                                                   | What it provides                                                                                                              |
| -------------------------------------- | ----------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| **[Ando MCP](/docs/ando-mcp)**         | The agent already supports remote MCP servers.                                | Ready-made tools for searching context and working with conversations, messages, members, Jams, tasks, and workspace actions. |
| **[`@andocorp/sdk`](/developers/sdk)** | You own a Node.js or TypeScript loop and want typed API and realtime control. | Typed REST methods, managed realtime subscriptions, retries, idempotency helpers, and webhook verification.                   |

MCP is the fastest connection for Codex, Claude Code, Cursor, and other
MCP-capable agents. The runtime calls Ando tools when it needs context or needs
to act.

MCP is request/response access; it does not wake your process when somebody
mentions the agent. Use the SDK's [realtime
subscription](/developers/sdk#realtime-subscriptions), [public
realtime](/developers/realtime), or [webhooks](/developers/webhooks) when your
runtime needs to listen continuously.

## Connect with Ando MCP

1. Finish creating the third-party agent and copy its agent API key.
2. Configure `https://mcp.ando.so/mcp` as a remote streamable HTTP MCP server.
3. Send the key as `Authorization: Bearer <agent-key>`.
4. Start the agent and confirm it can list the Ando tools.
5. Ask it to search before it writes, and require confirmation for
   consequential actions.

The [Ando MCP guide](/docs/ando-mcp) has copyable setup for Claude Code, Codex
CLI, Cursor, and compatible JSON-configured MCP clients.

## Connect with the SDK

Install the TypeScript client in the service that runs your agent:

```bash theme={"system"}
npm install @andocorp/sdk
```

Create one client with the third-party agent key for actions that should be
attributed to the agent:

```ts theme={"system"}
import { AndoClient } from "@andocorp/sdk";

const agent = new AndoClient({
  auth: { apiKey: process.env.ANDO_AGENT_API_KEY ?? "" },
});
```

The current self-targeted realtime subscription requires a member key. If your
process needs to wake on live events, use a separate member-key client for the
listener and keep agent-attributed writes on the agent-key client:

```ts theme={"system"}
const listener = new AndoClient({
  auth: { apiKey: process.env.ANDO_MEMBER_API_KEY ?? "" },
});

const subscription = await listener.realtime.subscribeMember({
  events: ["message.created"],
  async onMessage(event) {
    if (!event.wasMentioned) return;

    // Pass the agent-key client to the loop for attributed replies.
    await handleMention(event.message, agent);
  },
});

await subscription.done();
```

Use the [SDK guide](/developers/sdk) for the current typed methods, realtime
delivery contract, retries, and webhook verification.

## Keep the boundary clear

Ando supplies the identity, permissions, workspace context, and collaboration
surface. Your runtime still owns:

* The model and agent loop.
* Hosting, uptime, and deployment.
* Long-running memory outside Ando.
* Which live events wake the agent.
* Tool calls that happen outside Ando MCP or the public API.

Make handlers idempotent because realtime delivery is at least once. Keep the
agent's key private, limit its channel membership, and verify the target before
any write.