No-KYC managed MCP trading exchange for AI agents: sandboxed TypeScript SDK, isolated sub-accounts, perpetual futures.
Your Claude or Cursor session can now place trades directly — no API glue required
Turn what you learned into a concrete stack decision.
Want the shortlist in your inbox?
Subscribe for the weekly brief that turns new AI noise into the few tools and workflows worth testing.
No-KYC managed MCP trading exchange for AI agents: sandboxed TypeScript SDK, isolated sub-accounts, perpetual futures.
A new MCP server dropped this week that wires order execution straight into Claude and Cursor. No custom API wrapper, no auth dance, no separate trading bot codebase. Your agent calls buy the same way it calls a file read. That's a bigger deal than it sounds, and I want to walk through why.
Model Context Protocol (MCP) is the connector standard Anthropic shipped so AI models can talk to external tools without every developer reinventing the plumbing. Up until now, most crypto/DeFi integrations with MCP were read-only — price feeds, wallet balances, on-chain data lookups. Useful for research, useless for execution.
Eterna Hybrid Exchange's MCP server crosses that line. It exposes order placement, position management, and account state as MCP tools your agent can call natively. That means the same session where you're asking Claude to analyze a chart or summarize funding rates can also place the trade based on that analysis — same context window, same conversation, no copy-pasting a ticker into a separate app.
The framing in the tweet that sparked this piece is the important part: exchanges are going to stop competing on UI and start competing on how easy they are for an agent to trade through. That's a real shift in what "good UX" means. A slick charting interface is worth nothing to an agent. A clean, well-documented tool schema is worth everything.
You could always build this yourself — wrap an exchange's REST API, write a Python function, hand it to your agent as a custom tool. People have been doing that for two years. The difference with MCP is standardization and reuse.
A custom API wrapper is yours alone. You maintain it, you handle auth refresh, you patch it when the exchange changes an endpoint. An MCP server is shared infrastructure — the exchange maintains it, and it works identically whether you're driving it from Claude Desktop, Cursor, a custom agent harness, or whatever ships next quarter. You install it once and every MCP-compatible client gets trading access simultaneously.
That's the actual unlock: portability across agents, not just convenience for one agent.
Here's the concrete flow using Claude Desktop or Cursor with Eterna's MCP server.
1. Add the server to your MCP config.
In Claude Desktop, edit claude_desktop_config.json:
{
"mcpServers": {
"eterna-hybrid-exchange": {
"command": "npx",
"args": ["-y", "@eterna/mcp-server"],
"env": {
"ETERNA_API_KEY": "your-api-key",
"ETERNA_API_SECRET": "your-api-secret"
}
}
}
}
Same shape in Cursor's mcp.json — the config format is standardized across MCP clients, which is the whole point.
2. Generate scoped API keys, not your master account keys. Most exchanges running MCP servers let you set per-key trading limits (max order size, allowed pairs, withdrawal disabled). Set these before you connect anything to an LLM. Treat the key like you'd treat a key you were handing to a junior trader you just met.
3. Restart the client and verify the tools loaded. Ask your agent: "What trading tools do you have access to?" It should list something like get_balance, place_order, cancel_order, get_positions. If it doesn't see them, check your config JSON syntax first — that's the most common failure point.
4. Give it a bounded task. Don't start with "manage my portfolio." Start narrow:
"Check my USDC balance. If it's above 500, place a limit buy for 0.1 ETH at 2% below the current mid price. Show me the order details before confirming."
5. Watch the tool call. The agent will call get_balance, reason over the result, then call place_order with explicit parameters. You can see the exact payload before it executes — this is the auditability advantage over a black-box trading bot script running unattended.
6. Confirm on-exchange. Check the order in Eterna's own interface or via get_positions. If the numbers match what the agent said it did, you've got a working loop.
| | MCP server (Eterna) | Custom API bot | |---|---|---| | Setup time | Minutes — config + API key | Hours to days — auth, retries, error handling | | Maintenance | Exchange maintains it | You maintain it forever | | Works across agents | Yes — Claude, Cursor, any MCP client | No — locked to whatever you built it for | | Best for | Interactive, judgment-based trading with a human reviewing | High-frequency, fully autonomous strategies | | Latency | Fine for swing/position trades | Better — no MCP overhead, direct exchange connection | | Auditability | High — you see each tool call in the conversation | Depends entirely on your logging |
If you're running a strategy that needs to react in milliseconds, MCP isn't your answer — you want a direct exchange SDK and a dedicated execution engine. But if you want an AI agent that can research, reason, and then act on your behalf with you watching the decision trail, MCP is a genuinely better fit than most people's homegrown bots.
Connecting production keys with no limits. The agent will do exactly what you tell it, including badly-worded instructions. Scope API keys to specific pairs and a max order size before you ever open a chat session.
Treating agent trading as "set and forget." MCP tool calls are visible in your conversation for a reason — read them. An LLM misreading "2% below mid" as "2x below mid" is a plausible failure mode, not a hypothetical one.
Skipping the confirmation step. You can configure most MCP trading tools to require explicit confirmation before executing state-changing calls. Turn that on while you're still learning the tool's behavior. Turn it off only once you trust the pattern.
Assuming MCP means "safe by default." MCP is a transport standard, not a risk-management framework. The exchange's server can expose exactly as much or as little protection as it chooses to build. Read what guardrails Eterna's server actually enforces server-side (order size caps, rate limits) versus what's left entirely to your prompt.
It's a standardized plugin format that lets AI models like Claude call external tools — APIs, databases, in this case an exchange's order book — using a consistent schema. Instead of building a custom integration per tool, any MCP-compatible AI client can use any MCP server.
Only with scoped API keys (limited size, limited pairs, no withdrawal permission), explicit confirmation steps turned on, and a human reviewing tool calls — at least until you've watched it behave correctly across enough sessions to trust it. Treat it like delegating to a new hire, not like flipping on autopilot.
A custom bot is code you own and maintain against one exchange's API. An MCP server is infrastructure the exchange maintains and any MCP-compatible agent can use — Claude, Cursor, or whatever client you're running next year — without rewriting the integration.
→ Ask the index what to build your mcp servers stack
→ Free credits for these tools
Written by McKlaud AI. Want to know which AI tools actually fit your business? Get a free AI audit.