The exchange built for AI agents. One integration. $10B+ liquidity. The lowest fees. No KYC.
This document is the canonical reference for Eterna AI — intended for AI agents creating marketing content, influencers covering the product, and developers evaluating the platform.
Website: ai.eterna.exchange Twitter/X: @eterna_exchange Contact: contact@eterna.exchange License: MIT
Eterna AI is a managed infrastructure layer that lets AI agents trade cryptocurrency on perpetual futures markets — with zero setup, no KYC, and the lowest fees available.
Agents get a dedicated, isolated trading account with its own balances, positions, and credentials. They write TypeScript code against a 29-method SDK and execute it in a secure sandboxed runtime. This "code execution" model uses up to 90% fewer tokens than traditional tool-call-based integrations.
Traditional MCP servers expose one tool per API call. A simple strategy — check balance, scan tickers, read orderbook, calculate indicators, place an order with TP/SL — requires 5+ sequential tool calls, each consuming tokens for the request, response, and the LLM's reasoning about the next step. At scale, LLM costs eat into trading gains, making AI-powered trading economically unviable for most strategies.
Eterna's code execution model lets agents compose all of those operations in a single TypeScript block. One tool call replaces many, and the LLM reasons once instead of repeatedly. This isn't just an optimization — it's a fundamental shift in how AI agents interact with external systems, backed by research from leading AI labs:
- Anthropic found that presenting MCP servers as code APIs instead of direct tool calls reduced token usage from 150,000 to 2,000 — a 98.7% reduction — by letting the execution environment load only needed definitions and filter data locally before returning results to the model.
- Apple Research demonstrated that across 17 LLMs, agents emitting executable code achieved up to 20% higher success rates than those using JSON-based tool calls, because code naturally supports composing multiple operations and dynamically revising plans.
- Cloudflare showed that LLMs handle far more tools with greater complexity when presented as a TypeScript API rather than tool definitions, because models are trained on vast amounts of real-world code but only limited synthetic tool-call examples.
The platform handles everything agents shouldn't have to think about: account provisioning, key management, rate limiting, and exchange API changes.
| Metric | Value |
|---|---|
| Daily liquidity | $10B+ |
| Trading pairs | 500+ USDT-margined perpetual futures |
| Taker fee | 0.035% |
| Maker fee | 0.014% |
| Execution latency | <200ms |
| Setup time | 30 seconds |
| Infrastructure cost | $0 |
| KYC required | No |
Eterna's 0.014%/0.035% fee structure is the lowest available for AI agent trading.
- Connect — Add the Eterna endpoint to your AI client (one config block).
- Authenticate — Sign in via Google OAuth. A dedicated trading account is provisioned automatically on first login.
- Fund — Deposit crypto to the agent's account (10+ blockchain networks supported, auto-swap to USDT available).
- Trade — Agent writes and executes TypeScript using the 29-method SDK. All execution happens in a sandboxed Deno runtime.
- Withdraw — Agent can withdraw funds at any time via
submitWithdrawal(). Withdrawals are processed immediately.
Each agent gets:
- A dedicated trading account — funds and positions are completely separated from other agents.
- Scoped credentials — agents authenticate via OAuth and never handle exchange API keys directly.
- Full fund control — agents can deposit, trade, and withdraw. No funds are locked or inaccessible.
- Independent trading state — leverage settings, open orders, and positions belong solely to that agent.
Multiple agents can run in parallel without any risk of cross-contamination.
The full SDK is available inside the sandboxed TypeScript runtime. Agents access these methods directly in code (e.g., const balance = await eterna.getBalance()).
| Method | Description |
|---|---|
getTickers(symbol?) |
Price, 24h change, volume, funding rate |
getOrderbook(symbol, limit?) |
Live bid/ask depth (up to 200 levels) |
getInstruments(symbol?) |
Contract specs, tick/lot sizes, leverage limits |
| Method | Description |
|---|---|
getRsi(symbol, period?) |
Relative Strength Index |
getMacd(symbol, fast?, slow?, signal?) |
Moving Average Convergence Divergence |
getEma(symbol, period?) |
Exponential Moving Average |
getSma(symbol, period?) |
Simple Moving Average |
getBollingerBands(symbol, period?, multiplier?) |
Bollinger Bands (upper, middle, lower) |
getVwap(symbol) |
Volume-Weighted Average Price |
| Method | Description |
|---|---|
placeOrder(params) |
Market or limit order with optional TP/SL, leverage, reduceOnly |
closePosition(symbol) |
Close entire position at market price |
cancelOrder(symbol, orderId) |
Cancel a specific order |
cancelAllOrders(symbol?) |
Cancel all active orders |
setTradingStop(params) |
Modify TP/SL on an existing position |
setLeverage(symbol, leverage) |
Set leverage for a symbol (min 1x, max per-symbol) |
| Method | Description |
|---|---|
getBalance() |
Equity, available balance, margin, unrealized PnL |
getAccountInfo() |
Account configuration and status |
getAllCoinsBalance() |
Multi-coin wallet balances |
getPositions(symbol?) |
Open positions with entry/mark price, leverage, liquidation price |
getOrders(symbol?) |
Active and historical orders |
| Method | Description |
|---|---|
getAllowedDepositCoins() |
Coins and chains available for deposit |
getDepositAddress(coin, chainType) |
Generate a deposit address (ETH, Arbitrum, Solana, etc.) |
getDepositRecords(coin?) |
Deposit history |
transferToTrading(coin, amount) |
Move funds from Funding wallet to Trading wallet |
swapToUsdt(coin, amount) |
Convert a coin to USDT |
getCoinInfo(coin?) |
Coin metadata and network details |
| Method | Description |
|---|---|
getWithdrawableAmount(coin) |
Available withdrawal balance |
submitWithdrawal(params) |
Initiate a withdrawal |
getWithdrawalStatus(withdrawId) |
Check withdrawal progress |
Eterna AI can be consumed through multiple interfaces depending on the AI platform:
The managed MCP server exposes three tools over Streamable HTTP:
execute_code— Run TypeScript in the sandboxed Deno environment with access to the full 29-method SDK.search_sdk— Search SDK method documentation by keyword.search_examples— Find working code examples for common trading patterns.
Endpoint: https://mcp.eterna.exchange/mcp (Streamable HTTP / JSON-RPC 2.0)
Configuration (one JSON block in your MCP client):
{
"mcpServers": {
"eterna-trading": {
"type": "streamable-http",
"url": "https://mcp.eterna.exchange/mcp"
}
}
}No API key needed to start — the agent authenticates via OAuth on first connection. Any MCP-compatible client (including Cursor, Windsurf, etc.) can connect using this configuration.
Resources: eterna://risk-rules, eterna://api-reference
Built-in prompts: trading_guide, momentum_scalping_strategy, place_trade
Repository: github.com/EternaHybridExchange/eterna-mcp
The Eterna CLI lets agents execute TypeScript strategies, browse SDK documentation, and check account state from the command line.
| Command | Description |
|---|---|
eterna login |
Authenticate via Google OAuth (browser or device code flow) |
eterna execute <file> |
Run a TypeScript file in the Eterna sandbox |
eterna execute - |
Execute code piped via stdin |
eterna sdk |
Browse SDK methods interactively |
eterna sdk --search <query> |
Search SDK documentation |
eterna balance |
Check account balance |
eterna positions |
View open positions |
Install: npm install -g @eterna-hybrid-exchange/cli (or npx @eterna-hybrid-exchange/cli)
Repository: github.com/EternaHybridExchange/eterna-cli
A plugin for the OpenClaw AI agent framework that wraps the Eterna CLI into agent skills:
eterna_trading(always-on skill) — Teaches the agent to use CLI commands for trading, SDK browsing, and account management.onboarding(explicit invocation) — Guided 5-phase onboarding flow for new human users: market discovery → hypothetical trades → first deposit → first trade → preference learning.
Install: openclaw plugins install @eterna-hybrid-exchange/openclaw-plugin
Repository: github.com/EternaHybridExchange/openclaw-plugin
An AI agent monitors markets, runs technical analysis, identifies opportunities, and executes trades — all without human intervention. The agent uses SDK methods to scan tickers, confirm signals with RSI/MACD/orderbook data, and place orders with automatic stop-loss and take-profit levels.
A human trader uses an AI assistant (via Claude, Cursor, or a terminal) as a copilot. The trader asks questions ("What's the funding rate on ETHUSDT?", "Show me positions with unrealized loss"), and the AI queries the platform and executes orders on command.
Multiple specialized agents run in parallel — one for momentum scalping, another for mean reversion, a third for funding rate arbitrage. Each operates in its own isolated sub-account with separate funds and positions, eliminating cross-strategy risk.
Users on the Eterna web platform can follow and automatically mirror the trades of AI agents. Positions are replicated in real-time via event streaming.
Developers use the CLI or MCP server to prototype and test trading strategies. The search_sdk and search_examples tools help discover available methods and working code patterns.
┌──────────────────────────────────────────────────────┐
│ AI Agents │
│ (Claude, OpenClaw, and more...) │
└──────────┬───────────────┬───────────────┬───────────┘
│ │ │
MCP Server Eterna CLI OpenClaw Plugin
│ │ │
└───────────────┼───────────────┘
│
┌───────▼───────┐
│ MCP Gateway │
│ (NestJS) │
└───────┬───────┘
│
┌───────▼───────┐
│ Deno Sandbox │
│ (29 SDK │
│ methods) │
└───────┬───────┘
│
┌───────▼───────┐
│ Exchange │
│ (Perpetual │
│ Futures) │
└───────────────┘
All integration methods converge at the MCP Gateway, which manages authentication, sandbox execution, and the exchange API layer. The gateway handles credential management, rate limiting, and error translation so agents never interact with exchange credentials directly.
- Sandbox isolation — Agent code executes in a Deno runtime with no filesystem, network, or system access beyond the SDK methods. Agents cannot escape the sandbox or access other agents' data.
- Account isolation — Each agent's credentials are scoped to its own trading account. No cross-account access is possible.
- No direct exchange credentials — Agents authenticate via OAuth and never handle raw exchange API keys. The platform signs exchange requests on the agent's behalf.
- Full fund access — Agents can deposit, trade, and withdraw freely. There are no hidden holds or lock-ups.
- Minimal data footprint — No KYC data, identity documents, or personal information required. Agents authenticate with Google OAuth only.
| Metric | Eterna AI | Self-Hosted Bot | Direct Exchange API |
|---|---|---|---|
| Order placement | ~180ms | ~150ms + infra | ~120ms |
| Market data | ~80ms | ~60ms + infra | ~40ms |
| Setup time | 30 seconds | 15–30 minutes | 2–4 hours |
| Infrastructure cost | $0 | $5–50/month | $5–50/month |
| Taker fee | 0.035% | 0.055% (standard) | 0.055% (standard) |
| Maker fee | 0.014% | 0.020% (standard) | 0.020% (standard) |
| Key management | Automatic | Manual | Manual |
| Agent isolation | Built-in | Custom | Custom |
| Platform | Status | Method |
|---|---|---|
| Claude (Code, Desktop, claude.ai) | Live | MCP Server |
| OpenClaw | Live | CLI Plugin |
| Eterna CLI | Live | npm package |
| Any MCP-compatible client | Works today | MCP Server |
| ChatGPT | Coming soon | — |
| Gemini | Coming soon | — |
| LangChain | Coming soon | — |
| CrewAI | Coming soon | — |
| AutoGen | Coming soon | — |
Any AI tool that supports MCP Streamable HTTP connections (Cursor, Windsurf, etc.) can connect to Eterna today using the standard MCP configuration.
- 130+ additional API endpoints — expanding from 29 to full Bybit V5 coverage
- Cron-based runtime — scheduled strategy execution without LLM overhead
- Backtesting engine — historical kline replay with simulated fills and performance metrics (Sharpe ratio, max drawdown)
- Spot trading — USDT/USDC spot pairs alongside perpetual futures
- Strategy sandbox — isolated environments for strategy testing
Eterna AI is part of the broader Eterna Exchange — a hybrid perpetual futures exchange combining centralized exchange performance with decentralized exchange freedom:
- Non-custodial — wallet-based authentication (Ethereum + Solana)
- No KYC — trade immediately without identity verification
- Up to 100x leverage on perpetual futures
- Multi-chain deposits — 10+ blockchain networks with automatic USDT conversion
- Copy trading — follow and mirror AI agent strategies in real-time
- Referral program — tiered commission structure with affiliate dashboard
- Trading signals — built-in technical analysis with RSI, MACD, Bollinger Bands
- Gamification — quests, competitions, leaderboards, and arcade
Main platform: eterna.exchange
| Term | Definition |
|---|---|
| MCP | Model Context Protocol — an open standard for connecting AI agents to external tools and data sources |
| Perpetual futures | Crypto derivatives contracts with no expiry date, allowing leveraged long/short positions |
| USDT | Tether — the stablecoin used as the base currency for all trading on the platform |
| Agent account | An isolated trading account with its own balances, positions, and trading state |
| Sandbox | A secure Deno runtime environment where agent code executes with access only to SDK methods |
| Maker/Taker | Maker orders add liquidity (limit orders); taker orders remove liquidity (market orders). Maker fees are lower. |
| TP/SL | Take-profit and stop-loss — automatic exit orders that close a position at a target profit or maximum loss |
| Funding rate | A periodic payment between long and short traders that keeps perpetual futures prices aligned with spot |
- Leverage limits are per-symbol, determined by the exchange's contract specifications (viewable via
getInstruments()). There is no fixed platform-wide leverage cap. Some contracts support up to 100x. - No platform-enforced position limits. Risk management (position caps, exposure limits) is the agent's or developer's responsibility.
- Eterna does not provide financial advice. The platform provides infrastructure for AI-powered trading. Trading cryptocurrency futures involves significant risk of loss.
Last updated: 2026-04-15