Connect an AI agent

Epsilon speaks MCP natively, in two forms: a hosted read-only server for quotes and market data, and a local trading package that signs and places real orders with a wallet that never leaves your machine.

Which one do you want?

Non-developer overview (what to ask, how funds stay yours): epsilon.exchange/ai and the product docs.

Roadmap: execution on the hosted server

The hosted server is read-only today because a hosted write needs a user, not a key. Three things are being built, in this order, and will land under the same tool names the local package uses:

• OAuth 2.1 sign-in with your Epsilon account (Privy behind it) — paste the URL into Claude or ChatGPT, log in, done. Protected-resource metadata + dynamic client registration + PKCE.
• Approval links — a place_* call returns a link that opens the order in the Epsilon app; you sign it with your own wallet. No delegation, works in any client that can show a link.
• Agent grants — set caps once in the app (per order, per day, order types, tokens) and grant a capped signer; the server then signs within the budget and every result reports what remains. Same mechanism the Epsilon Telegram bot uses; enforced server-side, below the model.

Alongside: an interactive MCP App (quote → ticket → confirm inside the client), x402 pay-per-call for keyless writes, and a Stock Token eligibility acknowledgement on RWA buys.

Hosted server (read-only)

Point any Streamable-HTTP MCP client at the endpoint. No key needed to start: the docs-discovery tools (search_docs, list_examples, get_example) are public, so an agent can research the integration with zero setup. Market-data tools need a free API key:

{
  "mcpServers": {
    "epsilon": {
      "url": "https://api.epsilon.exchange/mcp",
      "headers": { "X-API-Key": "eps_YOUR_KEY" }
    }
  }
}

Rate limits and usage attribution are identical to the REST API — MCP tool calls dispatch into the same /v1 surface. Without a key, market tools return an error pointing at the dashboard where you can mint one.

Local package (trading)

The npm package adds non-custodial execution: it signs EIP-712 orders locally with a wallet you configure and submits only the signed payload. In Cursor (.cursor/mcp.json) or Claude Desktop / Claude Code (claude_desktop_config.json / .mcp.json):

{
  "mcpServers": {
    "epsilon": {
      "command": "npx",
      "args": ["-y", "@epsilon-exchange/mcp"],
      "env": {
        "EPSILON_API_KEY": "eps_YOUR_KEY",
        "EPSILON_WALLET_KEY": "0xYOUR_TRADING_WALLET_PRIVATE_KEY"
      }
    }
  }
}

Omit EPSILON_WALLET_KEY for a read-only connection. Then just talk to your agent:

"quote 0.5 WETH → USDG, then place a limit sell at 3100 expiring in 3 days"

The agent quotes, checks balance and router allowance, sends the ERC-20 approval if needed, signs, submits — and hands back the order hash.

Set up your client

Every MCP client works. Copy-paste setup for the common ones — use the local package for trading, the hosted URL for read-only.

Cursor

One-click install (opens Cursor; review the config, replace the placeholder key and wallet before saving):

➜ Add Epsilon to Cursor (trading, local)
➜ Add Epsilon to Cursor (read-only, hosted)

Or manually: Settings → Tools & MCPs → Add, or drop the JSON above into .cursor/mcp.json. The Epsilon plugin additionally installs trading skills and Robinhood Chain rules — install it in one click from cursor.directory/plugins/epsilon.

Claude Code

claude mcp add epsilon --env EPSILON_API_KEY=eps_YOUR_KEY --env EPSILON_WALLET_KEY=0x... -- npx -y @epsilon-exchange/mcp

Read-only alternative (hosted): claude mcp add epsilon --transport http https://api.epsilon.exchange/mcp --header "X-API-Key: eps_YOUR_KEY"

Claude Desktop

Settings → Developer → Edit Config and add the local package block to claude_desktop_config.json. (The hosted read-only server can also be added under Settings → Connectors → Add custom connector once key-in-URL auth is replaced by OAuth — until then, use the local package in Desktop.)

ChatGPT (Developer Mode)

Settings → Apps & Connectors → Advanced → Developer Mode, then add the hosted server URL https://api.epsilon.exchange/mcp with the X-API-Key header. Local stdio servers aren't supported in ChatGPT web — use the hosted read-only server there, and Codex for trading.

Codex (IDE) and Codex CLI

codex mcp add epsilon --env EPSILON_API_KEY=eps_YOUR_KEY --env EPSILON_WALLET_KEY=0x... -- npx -y @epsilon-exchange/mcp

Or in ~/.codex/config.toml:

[mcp_servers.epsilon]
command = "npx"
args = ["-y", "@epsilon-exchange/mcp"]
env = { EPSILON_API_KEY = "eps_YOUR_KEY", EPSILON_WALLET_KEY = "0x..." }

VS Code (Copilot agent mode)

One-click: ➜ Add Epsilon to VS Code (trading, local) — or put this in .vscode/mcp.json (workspace) or run MCP: Add Server from the command palette:

{
  "servers": {
    "epsilon": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@epsilon-exchange/mcp"],
      "env": { "EPSILON_API_KEY": "eps_YOUR_KEY", "EPSILON_WALLET_KEY": "0x..." }
    }
  }
}

Read-only alternative: { "type": "http", "url": "https://api.epsilon.exchange/mcp", "headers": { "X-API-Key": "eps_YOUR_KEY" } }.

Gemini CLI

gemini mcp add epsilon -e EPSILON_API_KEY=eps_YOUR_KEY -e EPSILON_WALLET_KEY=0x... npx -y @epsilon-exchange/mcp

Read-only alternative (hosted): gemini mcp add --transport http epsilon https://api.epsilon.exchange/mcp --header "X-API-Key: eps_YOUR_KEY". Both land in ~/.gemini/settings.json under mcpServers.

Grok

Start a chat → + → Add connector → Custom → paste https://api.epsilon.exchange/mcp (read-only).

Anything else

Any Streamable-HTTP client: https://api.epsilon.exchange/mcp + X-API-Key. Any stdio client: npx -y @epsilon-exchange/mcp. Registry entry: io.github.alienbase-xyz/epsilon.

Skills only (no MCP needed)

Teach any skills-compatible agent (Cursor, Claude Code, Codex, Cline, and 13+ others) the Epsilon trading and API-integration workflows in one command:

npx skills add alienbase-xyz/epsilon-plugin

Claude Code users can install it as a plugin instead (skills + MCP server in one step):

/plugin marketplace add alienbase-xyz/epsilon-plugin
/plugin install epsilon

In Cursor, you can also index the docs for @docs references: Settings → Indexing & Docs → Add doc and paste https://developers.epsilon.exchange/llms.txt (or llms-full.txt for inline code examples).

Then let the agent configure its own credentials — paste this prompt:

Create ~/.config/epsilon/.env with EPSILON_API_KEY (get a free key at
https://developers.epsilon.exchange/dashboard). If I want trading, also add
EPSILON_WALLET_KEY for a DEDICATED trading wallet — never my main wallet.
Open the file, remind me to paste the real values, make sure it's
git-ignored, then add the Epsilon MCP server from
https://developers.epsilon.exchange/mcp.html using those env vars.

Tool list

Verb-first names, one vocabulary across both servers (hosted v0.4.0, local @epsilon-exchange/mcp 0.4.0). Every description says when to use a sibling tool instead.

Agent recipes

Paste-ready prompts for the scheduling features your AI platform already has — ChatGPT Scheduled tasks, Claude routines, Cursor cloud-agent automations. Test any prompt in a normal chat before scheduling it.

Daily position check (read-only — safe to run unattended)

Every morning at 9:00, using the Epsilon MCP tools:
1. Call get_portfolio and list_orders for my wallet.
2. Compare with yesterday if you have it: report fills since the last
   check, orders expiring within 24h, and any position that moved more
   than 10% in USDG value.
3. If nothing meaningful changed, reply with one line: "No action needed."
Never place, modify, or cancel orders in this task.

Stop-loss babysitter (asks before acting)

Every hour: check my open Epsilon orders with list_orders. If my
stop-loss on [TOKEN] filled, quote the current [TOKEN]/USDG price and
propose (do NOT place) a re-entry limit order 5% below market. I will
confirm any order myself.

DCA report (weekly)

Every Sunday: summarize my Epsilon DCA progress — executions completed
vs. remaining from list_orders, average fill price so far vs. the current
get_quote price, and total spent. One short paragraph.

Give your coding agent context (AGENTS.md)

Building on Epsilon with Cursor, Claude Code, or Codex? Paste this into your repo's AGENTS.md / CLAUDE.md / Cursor rules so the agent lands on the right endpoints and signing scheme first try:

## Epsilon (Robinhood Chain DEX)
- Chain: Robinhood Chain, id 4663 · RPC https://rpc.mainnet.chain.robinhood.com
- API: https://api.epsilon.exchange/v1 (X-API-Key auth; free keys:
  https://developers.epsilon.exchange/dashboard)
- OpenAPI: https://developers.epsilon.exchange/openapi.json
- SDKs: `npm i @epsilon-exchange/sdk` (TS/viem) · `pip install epsilon-exchange`
- Orders are EIP-712, signed LOCALLY via the SDK's buildAndSignOrder —
  domain { name: "EpsilonRouter", version: "7", chainId: 4663 }. Never
  hand-roll the struct (v7.1 includes triggerAmountOut); never send keys.
- ERC-20s need a router allowance before placement (approveRouter).
- Rate limits (free): 120 quote / 600 read / 30 order per min. Poll orders,
  not quotes.
- Docs index for agents: https://developers.epsilon.exchange/llms.txt

Safety model

• The hosted server can never trade. Order placement requires the maker's EIP-712 signature, and hosted infrastructure holds no wallet keys.
• The local package is non-custodial. The wallet key lives in your MCP config, signs in-process, and is never transmitted. Funds stay in the wallet until a keeper fills the order on-chain.
• Use a dedicated trading wallet with limited funds for agent trading — same rule as any bot key.
• Spend cap: set EPSILON_MAX_ORDER_USD (e.g. "250") and the local server refuses any order valued above it — valued via a quote to USDG, and it fails closed if an order can't be valued.
• Two-step confirm: set EPSILON_REQUIRE_CONFIRM=1 and placement tools return a preview first; the agent must call again with confirm=true after you approve.
• Rev-share (for builders shipping this server to users): set EPSILON_REFERRER=0xYourAddress and the referral leg of every fill the server routes is paid to that address on-chain — permissionless, and it never changes what the maker pays (the fee ppm is policy-set; only the destination is yours).
• The API key on submissions is attribution and rate limiting; it cannot move funds by itself.