MCP server for agents

Give an AI agent its own private ZERO account. The ZeroTrace MCP server lets agents hold, pay, sell and get paid in ZERO on Robinhood Chain, signing with their own key.

The ZeroTrace MCP server gives an AI agent its own private ZERO account. Any agent that speaks the Model Context Protocol, such as Claude Code, Claude Desktop or Cursor, can use it.

The agent holds ZERO in private notes, pays people and services without showing its address, and gets paid at a private address. It signs with its own key, locally: there is no wallet to click through. Private actions need no ETH: their network fee is paid in ZERO.

Why agents

An agent that pays on-chain today shows everything: which services it uses, how much it spends, and, for a trading agent, its strategy. With ZeroTrace:

Its balance and its payments stay private. A private send shows neither side nor the amount.
It can get paid without revealing its address, at a private address.
You can give it a budget without giving it a wallet: send it a payment link. It can spend what the link holds and nothing more, and you can take back what it does not claim.
Every payment can come with a proof: a link that shows the recipient and the amount of that one payment, for invoices and receipts.

Set it up

The server is the npm package @zerotrace/mcp. It runs with Node 22 or later, on the agent's machine: the key never leaves it.

Claude Code

claude mcp add zerotrace \
  --env ZEROTRACE_PRIVATE_KEY=0x... \
  --env ZEROTRACE_MAX_ZERO=100000 \
  -- npx -y @zerotrace/mcp

Claude Desktop, Cursor and other clients

{
  "mcpServers": {
    "zerotrace": {
      "command": "npx",
      "args": ["-y", "@zerotrace/mcp"],
      "env": {
        "ZEROTRACE_PRIVATE_KEY": "0x...",
        "ZEROTRACE_MAX_ZERO": "100000"
      }
    }
  }
}

Settings

Variable	Default	What it does
`ZEROTRACE_PRIVATE_KEY`	required	The agent's key. Use a key made for the agent, not your own wallet's.
`ZEROTRACE_MAX_ZERO`	no limit	The most ZERO one action may move: send, pay, link, sell, unshield, shield.
`ZEROTRACE_MAX_ETH`	no limit	The most ETH one purchase may spend.
`ZEROTRACE_READ_ONLY`	off	`1` allows only the reading tools: nothing is signed or sent.
`ZEROTRACE_RPC_URL`	Robinhood Chain's public RPC	Another RPC endpoint.
`ZEROTRACE_BUNDLER_URL`	Pimlico's public bundler	Another ERC-4337 bundler.
`ZEROTRACE_INDEXER_URL`	the ZeroTrace indexer	Another indexer, or empty to read the chain only.

The key derives the same private account as the app does: importing it into a browser wallet and opening zerotrace.so shows the same balance and history.

Tools

Tool	What it does
`get_status`	Address, ETH, public and private ZERO, fees earned, payments waiting, registration, the network fee, the limits.
`get_history`	Recent private activity, rebuilt from the agent's own notes.
`refund_status`	What the agent can still have refunded from the earlier vault, and refunds claimed but not yet paid.
`claim_refund`	Refunds up to two of the agent's notes of the earlier vault into a private note; no ETH needed.
`quote`	ZERO for an amount of ETH, or ETH for an amount of ZERO.
`buy`	Buys ZERO with ETH straight into a private note.
`shield`	Moves public ZERO into a private note.
`register`	Registers the privacy key, so others can send to the agent's address privately.
`send_private`	Sends ZERO privately to a registered address, and returns a proof of payment.
`pay_private_address`	Pays a private address link: from the private balance, with ETH, or with public ZERO.
`create_payment_link`	Pays ZERO into a link anyone can claim.
`payment_link_status`	What a link holds, and whether it was claimed.
`claim_payment_link`	Claims a link into the private balance, or to an address. A link paid in the earlier vault is refunded into the private balance.
`sell`	Sells ZERO for ETH sent to an address.
`unshield`	Moves ZERO out as public ZERO.
`get_private_address`	The agent's private address link and fingerprint.
`collect_private_address`	Moves payments waiting at the private address into the balance.
`verify_payment`	Checks a proof-of-payment link against the chain.

Costs

Each private action (send, payment, link, sale, unshield, claim, collection) pays the vault's flat network fee, worth 0.0002 ETH, in ZERO; get_status shows it. Refunds of the earlier vault pay no fee: the refund contract pays the gas. Purchases, shields and registration are ordinary transactions paid in ETH by the agent's address. See Fees.

Keep it safe

The key is the account. Whoever has it can spend everything the agent holds. Give the agent a key of its own, fund it with what it needs, and set ZEROTRACE_MAX_ZERO and ZEROTRACE_MAX_ETH.
Payment links are bearer instruments. The agent should send them only to the payee, never post them.
Sales and unshields name a recipient. To keep a sale private, the agent should send the ETH to a new address, not its own.

Why agentsCopy Anchor Link

Set it upCopy Anchor Link

Claude CodeCopy Anchor Link

Claude Desktop, Cursor and other clientsCopy Anchor Link

SettingsCopy Anchor Link

ToolsCopy Anchor Link

CostsCopy Anchor Link

Keep it safeCopy Anchor Link

On this page