mcpField
A
agentic-pay

agentic-pay

Local
aumnium.techFinance0Updated 14w ago

About agentic-pay

agentic-pay is a cross-platform payment engine for AI agents to send and receive seven cryptocurrencies. It combines per-agent spending policies and an idempotent ledger, with self-hosted and hosted options.

Key features

  1. 01Send and receive seven cryptocurrencies
  2. 02Per-agent and daily spending caps
  3. 03Human-confirmation thresholds
  4. 04Address allowlisting
  5. 05Idempotent payment ledger

Use cases

  1. 01Let an AI agent pay across supported crypto rails
  2. 02Set limits on agent payment activity
  3. 03Prevent duplicate payments after a retry

MCP support

The project documents integration with MCP clients and exposes an HTTP-based agent integration path. The input does not specify an MCP server interface or tools.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

mcp.json · Universal config
{
"mcpServers": {
"shieldcubed-agentic-pay": {
"command": "npx",
"args": [
"-y",
"@shieldcubed/agentic-pay"
],
"env": {
"AGENTIC_PAY_AGENT_ID": "<AGENTIC_PAY_AGENT_ID>",
"AGENTIC_PAY_CONFIG": "<AGENTIC_PAY_CONFIG>",
"BTC_WIF": "<BTC_WIF>",
"ETH_RPC_URL": "<ETH_RPC_URL>",
"ETH_PRIVATE_KEY": "<ETH_PRIVATE_KEY>"
}
}
}
}
Run commandnpx -y @shieldcubed/agentic-pay
Environment variables to set
AGENTIC_PAY_AGENT_IDIdentifier for this agent, used to look up its spend-limit policy in config.json.
AGENTIC_PAY_CONFIGAbsolute path to your config.json (spend limits, API keys, static prices). Defaults to config/config.json in the install directory.
BTC_WIFSecretWIF-encoded Bitcoin private key for the funding wallet. Only required if using the BTC rail.
ETH_RPC_URLEVM JSON-RPC endpoint URL. Only required if using the ETH/USDT/USDC rails.
ETH_PRIVATE_KEYSecret0x-prefixed Ethereum private key for the funding wallet. Only required if using the ETH/USDT/USDC rails.

Local servers need a runtime on your machine (e.g. Node.js 18+). Config file locations differ by client; see your client’s docs.

Packages
npm@shieldcubed/agentic-pay0.1.1

Tools

5

Saved tool list · updated 3w ago

This tool takes no parameters.

Details

From the project README

Agentic Pay agentic-pay-avatar

A cross-platform payment engine that lets third-party AI agents send and receive payments over seven crypto rails: BTC, ETH, USDT, USDC, XRP, XMR, ZEC.

One Node.js core runs unmodified on Linux, Windows, and macOS. The same backend is reachable from iOS and Android via an installable Progressive Web App (PWA) — there is no separate native mobile codebase to maintain.

Architecture

                     ┌───────────────────────────┐
                     │   core/railManager.js     │  <- one call-site for
                     │  (policy + ledger + auth) │     every asset
                     └─────────────┬─────────────┘
                                   │
        ┌───────────┬─────────────┼─────────────┬───────────┬──────────┐
        │            │             │             │           │          │
     rails/btc   rails/eth    rails/xrp     rails/xmr    rails/zec       │
     (bitcoinjs) (ethers.js,  (xrpl.js)   (JSON-RPC to  (JSON-RPC to     │
                  ETH+USDT+                monero-       zcashd)         │
                  USDC ERC20)              wallet-rpc)                   │
                                                                          │
        Agent-facing surfaces (both call railManager, never a rail       │
        adapter directly):                                               │
        ┌────────────────────────┐   ┌───────────────────────────┐      │
        │ server/restApi.js      │   │ server/mcpServer.mjs      │      │
        │ HTTP/JSON, API-key     │   │ MCP stdio server for       │      │
        │ auth, for any HTTP-    │   │ Claude / other MCP-        │      │
        │ capable agent stack    │   │ compatible agent clients   │      │
        └────────────────────────┘   └───────────────────────────┘      │
                                                                          │
        Human-facing surfaces:                                           │
        ┌────────────────────────┐   ┌───────────────────────────┐      │
        │ cli/index.js           │   │ web/ (PWA)                │      │
        │ Linux/Windows/macOS    │   │ served by server/          │      │
        │ terminal                │   │ staticWeb.js, installable  │      │
        │                        │   │ on iOS/Android home screen │      │
        └────────────────────────┘   └───────────────────────────┘      │

Every send, from any surface, passes through core/limits.js (per-agent spend caps + human-confirmation floor) and core/ledger.js (idempotency, so a retried tool call can never double-pay).

Quick start (any OS with Node.js 18+)

git clone <this repo>          # or unzip the delivered archive
cd agentic-pay
npm install

cp config/.env.example .env
cp config/config.example.json config/config.json
# edit both files — see docs/SETUP_<YOUR_OS>.md for exact values per rail

npm run start:rest     # REST API on :8787
npm run start:web      # PWA on :8788 (optional, for mobile/browser access)
npm run start:mcp      # MCP stdio server (for Claude Desktop / Claude Code)
node cli/index.js rails   # sanity check from the terminal

Start on testnets first. Every rail's example config defaults to a testnet or requires you to explicitly fill in mainnet values — this is intentional. Do not point real funds at this system until you've reviewed core/limits.js and set spend caps you're comfortable with.

Hosted (custodial) — skip the setup

Don't want to run your own node? Aumnium operates a hosted instance at https://api.aumnium.tech — deposit USDC, get a spendable custodial balance, and start sending across all seven rails without installing or funding anything yourself.

This is a different trust model than the self-hosted instructions above: your funds sit in a pooled wallet operated by Aumnium (not your own keys), and each send is charged a 1% fee plus network cost, deducted from your balance. The self-hosted path above remains fully non-custodial; this hosted path trades that for convenience.

# 1. Get your deposit address
curl -H "x-api-key: YOUR_KEY" https://api.aumnium.tech/v1/deposit/address

# 2. Send USDC to that address on Ethereum mainnet

# 3. Claim your deposit once it confirms
curl -X POST -H "x-api-key: YOUR_KEY" -H "Content-Type: application/json" \
  -d \'{"txHash":"0x..."}\' \
  https://api.aumnium.tech/v1/deposit/claim

# 4. Send payments (billed per-call via x402, USDC on Base)
curl -X POST -H "x-api-key: YOUR_KEY" -H "Content-Type: application/json" \
  -d \'{"asset":"USDC","to":"0x...","amount":1,"idempotencyKey":"unique-key"}\' \
  https://api.aumnium.tech/v1/send

Contact [email protected] for an API key. Full endpoint list at https://api.aumnium.tech.

Where to go next

What's genuinely production-ready here vs. what's a starting point

  • Production-shaped: the policy engine (per-tx cap, daily cap, confirmation floor, address allowlisting), the idempotent ledger, and the unified rail interface.
  • Starting point, needs hardening for real money at scale: the JSON-file ledger (swap for a real database under load), the static USD price table (wire in a live price feed), and key storage (move from .env to an OS keychain or HSM/KMS for anything beyond development — see core/keystore.js for the extension point).

License

agentic-pay is licensed under the Business Source License 1.1 (see LICENSE). In plain terms:

  • You can use, modify, and self-host this freely — for yourself, your own organization, or your own agents, including production use.
  • You cannot turn around and offer it as a competing hosted/managed payments-as-a-service product to third parties without a commercial license.
  • On 2030-07-14, this version automatically converts to the Apache License 2.0 — fully open source, no restrictions.

Want a commercial license for a hosted/managed offering before then? Contact [email protected].

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.