MERX

MCP serverAI & models

Once added, your AI can trade TRON energy on an exchange built for AI agents. It brings 54 tools, 30 prompts, and 21 resources for working with energy on the TRON network, and it can coordinate with other agents through A2A and ACP.

Available today. Use it from your connected AI after setup.

No other account needed.

After adding it, connect your AI agent and try one of the 30 included prompts or a simple energy trade to see how the exchange works.

Then ask your AI: use MERX to get prices

What your AI can do with it

Trade TRON energy on behalf of an AI agent
Use 54 tools for energy exchange tasks
Draw on 30 prompts for common requests
Access 21 resources that come with it
Coordinate with other agents over A2A and ACP

From the project's README

As published by hovsteder/merx-mcp in README.md.

https://MERX.exchange

TRON infrastructure for AI agents.

66 MCP tools. Energy market across 6 providers. USDT/USDC/USDD payments. x402 v2 facilitator on TRON mainnet.

Documentation | API Reference | MCP Server

What is MERX — TRON infrastructure for AI agents
The problem — why TRON had no agent layer until MERX
Platform overview — MCP, agent payment service, x402, GasFree, energy aggregator
Quick start — 4 paths (web, REST/SDK, Claude Code plugin, MCP)
What sets MERX apart — only complete agent stack on TRON
Architecture
API overview
MCP server
SDKs
Real-time data
Payment methods
Standing orders and monitors
Savings calculator
Error handling
Security
Tested on mainnet
Comparison with alternatives
Documentation
License

What is MERX

MERX is the infrastructure layer for AI agents and agentic networks on TRON. Where Stripe is infrastructure for web commerce and Cloudflare for the open web, MERX is the missing infrastructure layer that lets autonomous AI agents discover, transact, and operate on TRON without ever touching energy, bandwidth, or low-level blockchain mechanics.

The platform exposes one coherent stack: 66-tool MCP server, agent payment service for TRC-20 stablecoins, x402 v2 facilitator (the only TRON facilitator in the coinbase/x402 ecosystem registry), GasFree transfers via a MERX-deployed mainnet controller, dedicated TRON RPC node, A2A (Google, 7 skills) and ACP (BeeAI, 7 capabilities) protocol coverage, and a natural language Policy Engine powered by Anthropic Claude.

Underneath those agent surfaces sits an energy aggregator across 6 active providers (CatFee, Netts, TronSave, iTRX, PowerSun, TEM) that routes resource purchases to the cheapest source automatically -- so when an agent calls send(), MERX estimates the energy required, buys only the deficit, and broadcasts the transaction. The agent never holds TRX or thinks about energy.

Any AI agent running in Claude, LangChain, CrewAI, Vertex AI, AutoGen, or BeeAI can send payments and acquire resources on TRON through a single integration with MERX.

Three ways to plug an agent into MERX:

MCP server -- 66 tools for AI agents. Hosted SSE at https://merx.exchange/mcp/sse (zero install) or local stdio via npx merx-mcp. Works with Claude, GPT, Cursor, Windsurf, and any MCP-compatible client.
Claude Code plugin -- one-line install for Claude Code. Auto-registers the MCP server, ships 6 slash commands and a tron-agent-engineer sub-agent. See Hovsteder/merx-claude-plugin.
REST API + SDKs -- direct programmatic access for agents that aren't using MCP. JavaScript (merx-sdk v2.1 on npm), Python (merx-sdk v2.1 on PyPI), or raw HTTP against /api/v1/ (70+ versioned endpoints).

For human users, the web platform at merx.exchange remains available for manual energy trading, dashboard, deposits, and withdrawals -- but the platform is built primarily for agents.

The problem

AI agents will become the dominant transactional users of stablecoins, and TRON -- home to USDD, $86B+ USDT, USDC, and the dominant chain for retail USDT in Southeast Asia, Africa, and Latin America -- is already the largest USDT-native network in the world.

But TRON has no infrastructure designed for agents:

No agent-native payment service. Existing TRON wallets are built for human users with mouse clicks and seed-phrase backups, not for autonomous programs that need to register addresses, send TRC-20s, watch for incoming payments, and create invoices via REST.
Energy and bandwidth are a UX dead-end. Every smart contract call on TRON requires energy. Without energy, TRX tokens burn as fees -- a single USDT transfer burns 3-13 TRX (~$1-4) for cold receivers. Renting energy from a provider drops the cost to ~$0.10 -- a 94% reduction -- but every provider has a different price, different API, different duration tiers, and different failure modes. No agent can be expected to manage that.
No x402 facilitator on TRON before MERX. The x402 protocol has already processed $43.57M in agent-to-agent payments on Base, Solana, Stellar, and Ethereum. TRON was completely absent from the coinbase/x402 ecosystem registry until MERX. Agents that wanted to pay for TRON-hosted APIs in USDT had no standardized way to do it.
Three agent protocols, zero TRON integrations. MCP (Anthropic), A2A (Google), and ACP (BeeAI) are the three major agent communication protocols. Until MERX, none of them had a deployed, production-grade TRON server. AI agents in Claude, Vertex AI, or BeeAI literally could not see TRON.

MERX builds the missing layer. AI agents call one API, hold zero TRX, and get paid / pay / send / receive in USDT, USDC, or USDD on the world's largest USDT network.

Without MERX	With MERX
Agent has to manage energy + bandwidth manually	`send()` estimates and provisions resources automatically
Agent has to hold TRX as gas	GasFree transfers — agents send stablecoins from zero-TRX wallets
Agent has to integrate every energy provider's API	One MERX API routes to the cheapest of 6 providers
No way to pay for TRON-hosted APIs in USDT	x402 v2 facilitator with full USDT/USDC/USDD support
No A2A/ACP discovery on TRON	Agent Card + Manifest live, 7 skills, 7 capabilities
Agent has to write its own MCP server for TRON	66 tools, 30 prompts, 21 resources, hosted
Address watching means polling RPC	`watch()` with sub-3-second webhook delivery via ZMQ

Platform overview

Component	Description
MCP server	66 tools, 30 prompts, 21 resources for AI agents. Hosted SSE at `https://merx.exchange/mcp/sse` (zero install) or local stdio. SEP-1649 server card. The largest TRON-native MCP server in production.
Claude Code plugin	One-line install: `/plugin marketplace add Hovsteder/merx-claude-plugin`. Auto-registers MCP, 6 slash commands, sub-agent.
Agent Payment Service	`agent.merx.exchange` -- non-custodial REST API. `register`, `send`, `receive`, `watch`, `invoice`, `batch`, `schedule`, `contacts`. USDT live; USDD/USDC next sprint.
x402 v2 Facilitator	`x402.merx.exchange` -- only TRON facilitator in the coinbase/x402 ecosystem registry. Three settlement schemes (`exact`, `exact_permit`, `exact_gasfree`) for USDT, USDC, USDD on TRON mainnet plus USDC on Base.
GasFree Transfer Service	Mainnet controller `TKjJ1r5XYqnLZmLakcP3knis7Lh6gm3qtR` activated 2026-04-08. TIP-712 PermitTransfer for USDT/USDC/USDD. Agents send stablecoins from zero-TRX wallets.
A2A Protocol (Google)	Agent Card at `/.well-known/agent.json`. 7 skills including `compile_policy`. Task-based execution with SSE streaming. Compatible with LangChain, CrewAI, Vertex AI, AutoGen, Mastra.
ACP Protocol (BeeAI)	Manifest at `/.well-known/agent-manifest.json`. 7 capabilities matching A2A skills. Run-based execution with long-polling.
Policy Engine	Natural language → standing orders, powered by Anthropic Claude Sonnet 4. Available as MCP tool, A2A skill, and REST endpoint.
Energy aggregator	Real-time price comparison across 6 active providers (CatFee, Netts, TronSave, iTRX, PowerSun, TEM). Routes orders to cheapest source. Underneath the agent surfaces.
Dedicated TRON RPC node	`rpc.merx.exchange`, sub-5ms read latency, 13.7ms broadcast. Trial 1,000 free requests; paid tiers with energy-spend waiver.
REST API	70+ versioned endpoints under `/api/v1/`. Idempotency-Key on POST. Standard error format.
WebSocket	Real-time TRC-20 transfer stream and price updates at `wss://merx.exchange/ws`.
JavaScript SDK	`merx-sdk` v2.1 -- AgentModule + SwapModule + 4 base modules. TypeScript types included.
Python SDK	`merx-sdk` v2.1 -- same surface in snake_case.
x402 middleware	`merx-x402` v2.0.0 -- one-line Express integration for x402 v2.
Documentation	38+ pages at merx.exchange/docs. API reference, MCP/A2A/ACP guides, x402 integration.

Quick start

Four paths depending on your use case. For AI agents, paths 3 and 4 are the primary surfaces. Path 1 (web) is for human operators; path 2 (REST/SDK) is for direct programmatic integration.

Path 1: Web platform (humans)

Go to merx.exchange. Sign in. Deposit TRX. Manage energy, agent API keys, and balance through the dashboard. No code required.

Path 2: REST API / SDK (programmatic)

Install the JavaScript SDK:

npm install merx-sdk

Use it in your application (replace merx_sk_your_key with your API key from merx.exchange):

import { MerxClient } from 'merx-sdk'

const merx = new MerxClient({ apiKey: 'merx_sk_your_key' })

// Get current prices from all providers
const prices = await merx.prices.list()
console.log(prices[0])
// { provider: "netts", price_sun: 22, available: 100000000 }

// Buy energy at best price
const order = await merx.orders.create({
  resource_type: 'ENERGY',
  amount: 65000,
  duration_sec: 300,
  target_address: 'TYourAddress...',
})
console.log(order.status)   // "FILLED"
console.log(order.cost_trx) // 1.4311

Python:

from merx import MerxClient

merx = MerxClient(api_key="merx_sk_your_key")

prices = merx.prices.list()
order = merx.orders.create(
    resource_type="ENERGY",
    amount=65000,
    duration_sec=300,
    target_address="TYourAddress..."
)

curl (no SDK needed):

# Public -- no auth required
curl https://merx.exchange/api/v1/prices

# Authenticated
curl -X POST https://merx.exchange/api/v1/orders \
  -H "Authorization: Bearer merx_sk_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "resource_type": "ENERGY",
    "amount": 65000,
    "duration_sec": 300,
    "target_address": "TYourAddress..."
  }'

Path 3: Claude Code plugin (one-line install)

If you're using Claude Code, this is the fastest path. The plugin auto-registers the hosted MCP server, ships 6 slash commands, and includes a tron-agent-engineer sub-agent specialized in agentic payment workflows on TRON.

/plugin marketplace add Hovsteder/merx-claude-plugin
/plugin install merx@merx

Then run /merx:setup to configure your MERX API key. Available commands:

Command	What it does
`/merx:setup`	First-time setup: API key, connection test, capability tour
`/merx:prices`	Live TRON energy and bandwidth prices across all providers
`/merx:buy-energy`	Buy energy via cheapest provider, delegated to a target address
`/merx:balance`	MERX prepaid balance, recent orders, free-tier usage
`/merx:tx`	Look up a TRON transaction with structured fields
`/merx:send`	Send TRC-20 stablecoin via the agent payment service

Source: github.com/Hovsteder/merx-claude-plugin.

Path 4: MCP for any AI agent (Claude, Cursor, Windsurf, custom)

Hosted (zero install) -- works with Claude.ai, Cursor, Windsurf, and any SSE-compatible MCP client:

{
  "mcpServers": {
    "merx": {
      "url": "https://merx.exchange/mcp/sse"
    }
  }
}

22 read-only tools are available immediately: prices, estimation, market analysis, on-chain queries, address lookups. No API key required.

To unlock trading tools, call set_api_key in any conversation:

set_api_key("merx_sk_your_key")
-> All 34 authenticated tools unlocked for this session.

To unlock write tools (send TRX, swap tokens), call set_private_key:

set_private_key("your_64_char_hex_key")
-> Address derived automatically. All 66 tools available.
-> Key never leaves your machine.

Local (stdio) -- full power with keys set via environment variables:

npm install -g merx

{
  "mcpServers": {
    "merx": {
      "command": "npx merx-mcp",
      "env": {
        "MERX_API_KEY": "merx_sk_your_key",
        "TRON_PRIVATE_KEY": "your_private_key"
      }
    }
  }
}

All 66 tools available from the first message.

Additional protocol support

MERX also exposes A2A and ACP for non-MCP orchestrators -- same backend, different discovery surface:

A2A (LangChain, CrewAI, Vertex AI, AutoGen, Mastra): Agent Card at https://merx.exchange/.well-known/agent.json -- 7 skills, SSE streaming
ACP (BeeAI): Manifest at https://merx.exchange/.well-known/agent-manifest.json -- 7 capabilities, run-based execution

Access levels

Configuration	Tools	Capabilities
No keys	22	Prices, estimation, market analysis, on-chain queries, address lookups
+ `MERX_API_KEY`	34	+ Orders, balance, deposits, standing orders, monitors
+ `TRON_PRIVATE_KEY`	66	+ Send TRX/USDT/USDC/USDD, swap tokens, approve contracts, execute intents, agent payments

What sets MERX apart

The only complete agent stack on TRON

MERX is the only TRON project that runs all three major agent protocols as production-grade services: MCP (Anthropic), A2A (Google, 7 skills), and ACP (BeeAI, 7 capabilities). TronLink published a core MCP library (@tronlink/tronlink-mcp-core v0.1.0, March 2026) but it is explicitly a building block, not a hosted service. MERX is the only TRON entry in the coinbase/x402 ecosystem partner registry.

Agent payment service with sub-3-second receive

agent.merx.exchange is non-custodial: agents register their own TRON address and MERX never holds private keys or controls funds. The ZMQ event listener matches incoming TRC-20 transfers (USDT, USDC, USDD, plus any other token in real time) and dispatches webhooks within ~3 seconds of on-chain confirmation. watch() provides persistent 24/7 address monitoring with per-token filtering. invoice() creates payment requests with payment links and automatic detection. batch() sends up to 50 transfers in one call.

x402 v2 facilitator with full TRON stablecoin coverage

x402.merx.exchange implements the standard /verify, /settle, and /supported endpoints, so any x402 client (including the Coinbase CDP reference implementation) interoperates out of the box. Three settlement schemes live on TRON mainnet: exact (direct TRC-20 transfer), exact_permit and exact_gasfree (TIP-712 PermitTransfer through MERX's own GasFreeController contract). USDT, USDC, and USDD all settled on mainnet with verified txids and on-chain commission collection. Among 15 known x402 facilitators, MERX is the only one supporting the full TRON stablecoin set.

GasFree zero-TRX sends

The MERX-deployed GasFreeController contract TKjJ1r5XYqnLZmLakcP3knis7Lh6gm3qtR went live on mainnet 2026-04-08 with three verified mainnet permitTransfer settlements (USDT, USDC, USDD). Agents send stablecoins from wallets that hold zero TRX -- the controller pulls value+fee from a per-user GasFree subaccount and the executor pays the broadcast gas. Single biggest UX barrier for agents on TRON, removed.

Resource-aware transactions

Every write operation (TRC-20 transfer, token swap, contract call) automatically estimates energy AND bandwidth needed, buys the deficit at the best market price across 6 providers, waits for delegation to arrive on-chain, then executes. The agent never burns TRX unnecessarily. Tested on mainnet: a USDT transfer with auto-resources saves up to 94% compared to burning.

Exact energy simulation

Before buying energy for swaps and contract calls, MERX simulates the exact transaction via triggerConstantContract with real parameters. No hardcoded estimates -- the precise energy amount is purchased. For a SunSwap V2 swap, simulation returned 223,354 energy; the on-chain transaction used exactly 223,354.

Natural language Policy Engine

"Keep 500,000 energy on my wallet. Buy when price drops below 55 SUN. Max 200 TRX per week."

The Policy Engine (powered by Anthropic Claude Sonnet 4) parses this instruction, generates structured standing orders with triggers, budget limits, and expiration, previews them for the user, and creates everything with one confirmation. Available through MCP, A2A skill, and REST endpoint. No competitor can replicate this without their own Anthropic integration, standing order infrastructure, and real-time provider price feeds.

Multi-provider energy routing (under the agent surfaces)

All 6 active energy providers are aggregated (CatFee, Netts, TronSave, iTRX, PowerSun, TEM). Orders are routed to the cheapest source automatically. If one provider fails or runs out of capacity, the next cheapest fills the order. Prices cover both energy and bandwidth across every available duration tier.

Standing orders + delegation monitors

Server-side 24/7 automation stored in PostgreSQL. Trigger types: price_below, price_above, schedule (cron), balance_below, delegation_expiry. Persists across restarts. Works when the client is offline. Auto-renew with configurable max price.

Full MCP protocol

The only TRON MCP server using all three MCP primitives: tools (66), prompts (30), and resources (21 -- 14 static + 7 templates). Two transport modes: hosted SSE (zero install) and local stdio (full key management). Three protocol versions supported: 2024-11-05, 2025-03-26, 2025-06-18.

Architecture

Platform overview

graph TB
    User[User / Application / AI Agent]
    Platform[MERX Platform<br>merx.exchange]
    PM[Price Monitor<br>polls every 30s]
    OE[Order Executor<br>routes to cheapest]
    DV[Delegation Verifier<br>confirms on-chain]
    TR[Treasury<br>balance management]
    RPC[TronGrid / GetBlock<br>TRON RPC]
    Providers[Energy Providers<br>all connected]
    TRON[TRON Blockchain]

    User -->|Web / API / SDK / MCP| Platform
    Platform --> PM
    Platform --> OE
    Platform --> DV
    Platform --> TR
    PM -->|Price polling| Providers
    OE -->|Order routing<br>cheapest first| Providers
    DV -->|Verify delegations| RPC
    RPC --> TRON
    Providers -->|Delegate energy<br>+ bandwidth| TRON

    style User fill:#1a1a2e,stroke:#B8963E,color:#F5F0E8
    style Platform fill:#0C0B09,stroke:#B8963E,color:#F5F0E8
    style TRON fill:#141310,stroke:#B8963E,color:#F5F0E8

User / Application / AI Agent
    |
    | Web / REST API / SDK / MCP
    v
+----------------------------------+
|         MERX Platform            |
|         merx.exchange            |
|                                  |
|  +------------+ +-------------+  |
|  |   Price    | |   Order     |  |
|  |  Monitor   | |  Executor   |  |
|  | (every 30s)| | (cheapest)  |  |
|  +------------+ +-------------+  |
|  +------------+ +-------------+  |
|  | Delegation | |  Treasury   |  |
|  |  Verifier  | |  Manager    |  |
|  +------------+ +-------------+  |
+----------------------------------+
    |                    |
    v                    v
TronGrid / GetBlock   Energy Providers
(TRON RPC)            (all connected)
    |                    |
    v                    v
+----------------------------------+
|        TRON Blockchain           |
+----------------------------------+

Key architecture principle: All traffic goes through the MERX platform. Users never need TronGrid API keys. MERX manages all RPC infrastructure, caching, and failover server-side. The only operation that stays on the client: transaction signing with a private key. Private keys never leave the client process.

Resource-aware transaction flow

This sequence diagram shows a real USDT transfer with auto-resource optimization. Numbers are from production testing.

sequenceDiagram
    participant C as Client
    participant M as MERX
    participant P as Providers
    participant T as TRON

    C->>M: POST /orders or transfer_trc20(USDT, 100, TAddr)
    M->>M: POST /estimate (trc20_transfer)
    Note over M: energy: 7,896 / bandwidth: 345
    M->>M: GET /chain/resources/TSender
    Note over M: energy: 0 / bandwidth: 0 / free BW: 600
    Note over M: Energy deficit: 7,896 (round up to 65,000 min)<br>Bandwidth: 345 < 1,500 min order, skip
    M->>P: Route order: ENERGY, 65,000, 300s
    P-->>M: FILLED at 22 SUN (1.43 TRX)
    Note over M: Poll every 2s until delegation arrives
    M->>T: Verify delegation on sender address
    T-->>M: energy: 65,050 available
    Note over M: Sign TX (client-side if MCP, server-side if API)
    M->>T: Broadcast signed TX
    T-->>M: TX confirmed
    M-->>C: USDT sent. Cost: 1.43 TRX.<br>Burn alternative: 3.66 TRX. Savings: 87.6%

Shortened here. Read the whole README on GitHub.

Tools it offers (66)

What this server listed when ahel dialed its public endpoint in Sep 2026, with no key and no account of yours. The names are the server’s own.

get_prices
get_best_price
analyze_prices
get_price_history
compare_providers
estimate_transaction_cost
check_address_resources
create_order
get_order
list_orders
ensure_resources
wait_for_delegation
get_balance
get_deposit_info
get_transaction_history
explain_concept
suggest_duration
calculate_savings
list_providers
get_account_info
get_trx_balance
get_trc20_balance
get_transaction
get_block
get_chain_parameters
convert_address
get_trx_price
validate_address
search_transaction_history
transfer_trx

Signals

GitHub stars: 3
Last commit: Apr 2026
Weekly downloads: 127

Advanced

Delivery: mcp MCP server → your ahel gateway (mcp.ahel.ai) → every connected AI client.
Catalog kind: mcp-server
Gateway key: exchange-merx-mcp
Source: github.com/hovsteder/merx-mcp
Hosted endpoint: https://merx.exchange/mcp/sse

github.com/hovsteder/merx-mcp

More in AI & models

atom-mcp-server
MCP server · a7om-ai ottasia
MCP server · aiweather-anurag unphurl
MCP server · 123ergo free-blueprints
MCP server · agent-blueprint context7
MCP server · upstash tldraw
MCP server · tldraw

MERX

What your AI can do with it

From the project's README

https://MERX.exchange

Table of contents

What is MERX

The problem

Platform overview

Quick start

Path 1: Web platform (humans)

Path 2: REST API / SDK (programmatic)

Path 3: Claude Code plugin (one-line install)

Path 4: MCP for any AI agent (Claude, Cursor, Windsurf, custom)

Additional protocol support

Access levels

What sets MERX apart

The only complete agent stack on TRON

Agent payment service with sub-3-second receive

x402 v2 facilitator with full TRON stablecoin coverage

GasFree zero-TRX sends

Resource-aware transactions

Exact energy simulation

Natural language Policy Engine

Multi-provider energy routing (under the agent surfaces)

Standing orders + delegation monitors

Full MCP protocol

Architecture

Platform overview

Resource-aware transaction flow

Tools it offers (66)

Signals

More in AI & models