Agentfeed Mezo MCP Server

AgentFeed on Mezo

Live crypto data for AI agents, paid per call in MUSD, the Bitcoin-backed dollar on Mezo. The agent signs one permit and pays no gas. There is no account and no API key.

The gateway at https://mezo.ochinimus.app answers 402 Payment Required with a price, the token, the network and a one-time nonce. The agent signs an EIP-2612 permit for exactly that amount, sends the request again, and gets the data back with a link to the settlement. If the data cannot be fetched, nothing is charged.

It sells AgentFeed's market data (prices, liquidations, funding, a page summary) and two routes about Mezo itself: where MUSD trades against a dollar, and the health of a Mezo trove. The people who run agents can keep them on a budget from Telegram.

Use it from an MCP client

The server is on npm and in the official MCP Registry as io.github.seekdaseek/agentfeed-mezo. Add it to your client's MCP config:

{ "mcpServers": { "agentfeed-mezo": { "command": "npx", "args": ["-y", "@seekdaseek/agentfeed-mezo"],
  "env": { "NETWORK": "mezo-testnet", "AGENT_PRIVATE_KEY": "0x...", "MAX_PRICE_MUSD": "0.10" } } } }

Two tools: list_routes (free, reads the prices) and call_route { route, params?, scheme? } (signs one permit, returns the data and the explorer link). The server signs only for the network and the MUSD token it was configured for, and never above MAX_PRICE_MUSD. It sends the key nowhere.

NETWORK=base spends real money. To get MUSD on Base, swap USDC for it in the PancakeSwap V3 MUSD/USDC pool (0.01% fee): 0xa0EED82e…EE7E. MUSD on Base is 0xdD468A1DDc392dcdbEf6db6e34E89AA338F9F186. That pool is thin: buy only what you need and check the quote first. On Mezo testnet, test MUSD comes from opening a trove against test BTC from the faucet: AGENT_PRIVATE_KEY=0x... TARGET_ICR_PCT=165 node scripts/fund-musd.mjs --send in a clone (165 keeps the trove within what one faucet request provides).

From the command line

git clone https://github.com/seekdaseek/agentfeed-mezo && cd agentfeed-mezo && npm install
AGENT_PRIVATE_KEY=0x... NETWORK=mezo-testnet node src/client.js sol-price --pretty
AGENT_PRIVATE_KEY=0x... NETWORK=base node src/client.js liquidations symbol=SOL limit=5

Options: --scheme permit|transfer, --n 5 (repeat), --pretty. permit (default) costs the agent no gas. transfer sends a plain MUSD transfer and presents its hash with a signed claim; the agent pays the gas.

Routes and prices

Prices are MUSD per call on Mezo testnet and Base. A Mezo mainnet gateway would add 2 cents for gas.

Free: GET / (page), /.well-known/x402 (manifest with the prices per network), /stats, /payments.csv (every settled payment with its transaction), GET /agents/<address> (a registered agent's remaining budget), GET /nonce/<chainId>/<address>.

Budgets for agents, from Telegram

@AgentFeedBudgetBot lets the person who runs an agent set what it may spend. The gateway enforces it: a call from a registered wallet that would go over its budget or its daily cap is refused before anything is fetched or settled, and nothing is charged. The bot answers private chats only.

The floor is checked by the bot, off-chain, from fresh reads right before it submits the draw. Mezo itself only enforces 110%. A price move between the check and the block is not covered, and nothing on-chain would stop a draw the bot did not make.

Sample paid transactions

• Base, mezo-peg called from an MCP client with NETWORK=base: 0xa931415c…938e
• Mezo testnet, a trove draw funding an agent: 50 MUSD minted to the agent wallet, trove from 156% to 153% with a 150% floor: 0x9bcd592c…d06d
• Mezo testnet, that agent paying 0.02 MUSD for liquidations out of the drawn MUSD: 0x2af1ae19…a44c

The Telegram session behind the two testnet transactions is in evidence/bot-demo-transcript.md, with the user id removed. The gateway's ledger is public at /payments.csv, and node scripts/verify-evidence.mjs re-reads every row from its chain.

How a payment works

1. GET /api/<route> without payment returns 402 with a PAYMENT-REQUIRED header (and the same JSON in the body): for each network, the MUSD contract, the price in wei, the treasury, the gateway's settler address, and a nonce bound to the route, the network and the price.
2. The agent reads its permit nonce, signs Permit(owner, settler, price, nonce, deadline) with the token's own EIP-712 domain, and retries with a PAYMENT-SIGNATURE header.
3. The gateway checks the network, the token, the recipient and the nonce; recovers the signature; reads the balance; simulates permit() on-chain; and, for a registered agent, checks its budget and cap.
4. It fetches the data first. Only if that works does it call permit() and transferFrom() from its settler key, paying the gas, and return the data with the settlement transaction. A failed fetch or a failed settlement charges nothing.
5. Every signature, permit nonce, challenge nonce and settlement hash is recorded per network and refused a second time. MUSD has no EIP-3009 transferWithAuthorization, which is why this uses a permit.

Addresses

Mezo mainnet MUSD (chain 31612) is at the same address as on Base. The Mezo Borrow addresses are in src/config.js, taken from the Mezo MUSD repository.

Run your own gateway

npm install && npm test
cat > .env <<'EOF2'
NETWORKS=mezo-testnet,base            # which networks to sell on
TREASURY_ADDRESS=0x...                # mezo-testnet: receives the MUSD
SETTLER_PRIVATE_KEY=0x...             # mezo-testnet: permit spender, needs a little BTC for gas
BASE_TREASURY_ADDRESS=0x...           # base; the same pair for mezo-mainnet is MEZO_MAINNET_*
BASE_SETTLER_PRIVATE_KEY=0x...        # needs a little ETH for gas
CHALLENGE_SECRET=<random hex>
UPSTREAM_KEY=afk_...                  # an AgentFeed prepaid key
PUBLIC_URL=http://localhost:3034
OWN_WALLETS=0x...,0x...               # your own payers, counted apart from outside payers in /stats
EOF2
chmod 600 .env && npm start           # the gateway
npm run bot                           # the budget bot, with TELEGRAM_BOT_TOKEN added to .env

A network without its own treasury and settler key refuses to start. More settings are in src/config.js.

Tests

npm test runs 148 tests with no network: the gateway over a fake chain and a fake data source with real signatures (payment checks, replay, wrong token, wrong chain, wrong recipient, expired nonce, upstream down), the three networks, budgets and caps, the bot's commands, trove draws and the floor, the two Mezo routes, and the MCP server driven through a client. The last run passed all 148.

Limits, as they stand today

• Mezo testnet is test money. Base is real MUSD. The live gateway sells on those two. Mezo mainnet is supported in the code and tested, but not turned on.
• MUSD on Base is thinly traded. The pool above held about $430 of liquidity when checked, and selling 100 MUSD there returned about 0.968 USDC per MUSD. Buy small.
• The trove floor is off-chain and only as good as the bot's reads (see above). Draws work on Mezo only, and the demo above is on testnet.
• One permit at a time per wallet, and one call at a time per registered agent across networks.
• Use permit for registered agents. With the transfer scheme the agent has already paid when the gateway checks its budget, so an over-budget call would be refused after the payment. Read GET /agents/<address> first if you must use it.
• The public RPC nodes lag. A permit nonce that was just used can still read as current, so the gateway keeps its own ledger as a floor and the client takes the highest value it can see. A refusal caused by lag charges nothing with permit. With transfer, a payment can be refused if the gateway's node has not yet seen the receipt; the gateway retries for about 8 seconds, and a payment that was sent but never accepted cannot be redeemed (one case).
• The data behind the routes comes from AgentFeed through one prepaid key, with a daily cap on upstream calls. When it runs out a call fails with 503 and charges nothing.
• The bot answers one command a second per person and runs on a small server, so it can be down. A registered wallet stays gated by its budget for good, and revoke is final.
• Not audited. Use dedicated wallets with small balances.

License

MIT, see LICENSE.