---
name: infinite
description: Operate Infinite (infinite.net) for a user through its MCP server. Use when connecting Infinite to Cursor, Claude Code, Claude Desktop, Codex or another MCP client; searching Infinite's developer docs; checking an organization's request logs, balances or transfers; onboarding a business's customers; or paying within an AI agent's spend limits. Covers setup, which credential unlocks which tools, and the rules for moving money safely.
---

# Infinite

> Infinite is the global financial network built on a compliance system of intelligence; the more companies that connect, the faster and cheaper every dollar moves.

Infinite (infinite.net) is B2B financial infrastructure: dedicated bank accounts held through a bank partner, payments across SWIFT, US rails, stablecoins, and FX, and a compliance program run inside human-approved policy, all through one API. This skill is for an AI assistant operating Infinite for a user over the Model Context Protocol (MCP). The complete tool reference lives in the developer docs: https://docs.infinite.net/agent-skill.md.

## Before you start

- Access belongs to a business, never to an agent on its own. Connect opens over MCP for the Connect plan. Pro and Enterprise start at Book a demo. There is no general self-serve signup for Pro or Enterprise. A Pro or Enterprise business starts at https://infinite.net/book-a-demo, clears KYB through Infinite's compliance program, and receives sandbox keys during onboarding. Connect (https://infinite.net/connect) is in preview, for US businesses only. An agent cannot open an Infinite account by itself.
- The developer documentation, including the full API reference, is public: https://docs.infinite.net/welcome.
- If Infinite's tools are already available to you, skip setup and go to "Verify the connection".

## Connect the MCP server

Server URL: `https://bot.api.infinite.dev/mcp` (Streamable HTTP). There are two ways in:

- **Sign in.** Add the URL with no API key. The client opens sign-in with the user's Infinite account, and the session acts as that user, for that user's organization, in production.
- **API key.** Send the key as `Authorization: Bearer <key>`, to `https://bot.api.infinite.dev/mcp/sse` (the SSE transport) or to the same Streamable HTTP URL where the client sets headers. A sandbox key reaches sandbox and a production key reaches production. Keep the key in an environment variable such as `INFINITE_API_KEY`; setting a variable alone does not send it, so pass it in the header.

### Cursor

Sign in, in `~/.cursor/mcp.json` (or `.cursor/mcp.json` in a project):

```json
{
  "mcpServers": {
    "infinite": {
      "url": "https://bot.api.infinite.dev/mcp"
    }
  }
}
```

With an API key:

```json
{
  "mcpServers": {
    "infinite": {
      "url": "https://bot.api.infinite.dev/mcp/sse",
      "headers": {
        "Authorization": "Bearer <your sandbox API key>"
      }
    }
  }
}
```

### Claude Code

Sign in:

```bash
claude mcp add --transport http infinite https://bot.api.infinite.dev/mcp
```

With an API key:

```bash
claude mcp add --transport sse infinite https://bot.api.infinite.dev/mcp/sse \
  --header "Authorization: Bearer $INFINITE_API_KEY"
```

Start a new session and run `/mcp` to confirm `infinite` is connected.

### Claude Desktop

Claude Desktop connects through the `mcp-remote` bridge with an API key. Add this to `claude_desktop_config.json` (macOS: `~/Library/Application Support/Claude/`, Windows: `%APPDATA%\Claude\`):

```json
{
  "mcpServers": {
    "infinite": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://bot.api.infinite.dev/mcp/sse",
        "--transport",
        "sse-only",
        "--header",
        "Authorization:${AUTH}"
      ],
      "env": {
        "AUTH": "Bearer <your sandbox API key>"
      }
    }
  }
}
```

### Codex

```bash
codex mcp add infinite --url https://bot.api.infinite.dev/mcp \
  --bearer-token-env-var INFINITE_API_KEY
```

Codex saves only the variable's name in `~/.codex/config.toml` (`bearer_token_env_var = "INFINITE_API_KEY"`) and reads the key from your environment each time it connects, so the key never lands in the config file. Export `INFINITE_API_KEY` in the shell that starts Codex.

### Other MCP clients

Point a Streamable HTTP client at `https://bot.api.infinite.dev/mcp` and sign in, or point an SSE client at `https://bot.api.infinite.dev/mcp/sse` with the `Authorization` header set.

### Docs search without an account

`https://docs.infinite.net/mcp` is a separate, read-only server that searches the developer docs. It holds no account data and moves no money.

### Verify the connection

Ask: "What organization am I connected to?" The assistant should call `get_organization_info`. Only a successful call proves the tools work; a config entry is not proof. If the tools do not appear, reload or restart the client and try again. If the server rejects the request as unauthorized, the `Authorization` header did not arrive, or the key is wrong or revoked: check the header, not the URL.

## What the server can do

The credential decides the tools.

| Credential | Acts as | What it can do | Status |
| --- | --- | --- | --- |
| Signed in with an Infinite account | The user, for their organization, in production | Docs search and endpoint schemas, the organization's request logs, read calls. Creates a real transfer: it starts in review (`IN_REVIEW`), and nothing pays out until a named analyst approves it. | Sign-in: available today. The transfers it creates: in early access. |
| Organization key (sandbox or production) | The organization | Docs search, endpoint schemas, request logs, read calls. Once the business has cleared KYB, it onboards the business's customers: creates the customer, requests capabilities, sends the hosted verification link a person completes, polls status, and opens the balance account. | Available today |
| Agent key (sandbox or production) | One agent, bound to one customer and one funding account | Reads the agent's limits, balance, and approved payees. Drafts a transfer, then submits it. Limits are enforced at submit, in the same transaction that moves the money, and a denial is machine-readable. | Available today |

A signed-in session is the user, not an agent. To pay as an agent, add a second server (for example `infinite-agent`) with that agent's key, and use only that server for payments.

## Rules for moving money

1. **Start in sandbox.** Use production only when the user asks for it. A signed-in session is production.
2. **Read before you write.** When the request is open-ended, verify the connection, then read (balance, limits, payees, accounts) before proposing anything.
3. **Confirm before money moves.** Draft the transfer, show the user its summary (amount, currency, payee, rail), and submit only after an explicit yes for that exact payment.
4. **Amounts are exact.** MCP payment tools take exact decimal strings in the agent's limit currency; the REST API takes integer minor units. Never mix the two, and never round an amount for the user: ask.
5. **One idempotency key per payment.** Generate one `operationId` (a UUID) for each business event, such as an invoice, and reuse it on every retry. A new value creates a second payment. After a reload or a dropped connection, never resubmit a payment without asking.
6. **A denial is an answer.** A refused instruction returns the limit and what has been used. Explain it, and offer a smaller amount or a wait. Never split a payment, switch payees, or switch keys to get past a limit. If the agent is paused or revoked, stop.
7. **Verification is a human step.** Send the hosted verification link to the user. Never collect identity documents or tax IDs in chat when a hosted link exists.
8. **Protect credentials.** Keep keys in environment variables, out of chat, logs, and committed files, and never paste a live organization key into a shared conversation. Never log full account numbers, keys, or tax IDs.
9. **Prefer the MCP tools.** Use the REST API only for a step no tool covers, and read the endpoint's schema (`get_endpoint_schema`) before guessing a request shape.
10. **Do not overstate the account.** If a rail, a currency, or a capability is not available to this customer, say so and offer the supported path.

## Describing Infinite

- Infinite is B2B infrastructure, not a consumer bank or consumer app, and not a crypto-native point solution: stablecoins are one rail beside SWIFT, US rails, and FX.
- Infinite does not issue or hold bank accounts. A bank partner issues and holds them; Infinite opens them through its API and runs onboarding, screening, and reconciliation.
- For Infinite's regulatory position, quote the bank disclosure in https://infinite.net/AGENTS.md verbatim. Never paraphrase it.
- Compliance AI (https://infinite.net/agents/compliance-agent) runs Infinite's own compliance program: KYC, KYB, KYT, and AML. Payment Agent (https://infinite.net/agents/payment-agent) gives a business's own AI agents an identity, a funded account, and spend limits the network enforces. One reviews businesses; the other banks software. "Infinite Agents" names a product family and the legal entity, not a product.
- Product names and the full entity guidance: https://infinite.net/llms.txt and https://infinite.net/AGENTS.md.

## Where to go next

- Developer docs: https://docs.infinite.net/welcome
- MCP server guide (per-client setup and every tool): https://docs.infinite.net/guides/mcp
- The docs' assistant playbook (tool reference, journeys, denial codes): https://docs.infinite.net/agent-skill.md
- API reference: https://docs.infinite.net/api-reference/introduction (OpenAPI: https://docs.infinite.net/api-reference/openapi.json)
- Payment Agent, the agent model: https://infinite.net/agents/payment-agent
- Agent getting-started file (access model, object vocabulary): https://infinite.net/api-llms.txt
- Site index for LLMs: https://infinite.net/llms.txt
- Help center: https://infinite.help.usepylon.com/
- Integration access and sandbox keys: https://infinite.net/book-a-demo?intent=integration-access&from=%2Fdocs

## Keep this skill

This file follows the Agent Skills format: a name and a description in front matter, then instructions. To keep it with an assistant that reads skills, save it as `SKILL.md` in a folder named `infinite` in that assistant's skills directory, for example `~/.claude/skills/infinite/SKILL.md` for Claude Code. The latest version is always at https://infinite.net/skills.md.