Skill Proposal: Agent Payments via AgentPay MCP (x402 Protocol)

[up2itnow0822]

The Gap

everything-claude-code has 116 skills covering architecture, testing, security, content, databases, Kubernetes, PyTorch, and more. There's no skill for agent payments.

This isn't unique to ECC - it's a pattern across every major agent harness framework. But with 96K+ stars and the skill architecture ECC has built, this is the right place to close that gap.

What I Built

AgentPay MCP is an MCP server that gives any Claude Code session non-custodial USDC payment capabilities via the x402 protocol.

Three tools:

• create_wallet - Generates a non-custodial wallet on Base
• send_payment - Sends USDC with x402 protocol headers (for API monetization, compute purchases, agent-to-agent settlement)
• check_balance - Reads wallet balance for autonomous spending decisions

The x402 protocol handles the payment flow: server returns HTTP 402 -> agent reads payment terms -> pays automatically -> retries with receipt. $24.24M/month in production volume on x402 infrastructure today.

Why It Fits ECC's Architecture

AgentPay MCP drops in as a standard MCP server configuration:

{
  "mcpServers": {
    "agentpay": {
      "command": "npx",
      "args": ["-y", "agentpay-mcp"],
      "env": {
        "NETWORK": "base",
        "SPENDING_LIMIT_DAILY": "50"
      }
    }
  }
}

The SpendingPolicy config aligns with ECC's security model - operators control daily limits, per-transaction caps, and recipient allowlists. Same philosophy as ECC_HOOK_PROFILE gating: capabilities with operator-controlled boundaries.

A dedicated skill file (similar to mcp-server-patterns or api-design) would cover:

• Wallet lifecycle management across sessions
• SpendingPolicy configuration patterns
• Integration with ECC's hook system for payment logging
• Security considerations for agent-held keys

Credentials

This isn't a cold pitch. We shipped the x402 payment tool integration into NVIDIA's NeMo Agent Toolkit Examples (PR #17, merged). The same integration pattern applies here.

• npm: agentpay-mcp
• GitHub: up2itnow0822/agentpay-mcp

What I'm Proposing

I'd like to contribute:

1. An agent-payments skill for the skills directory
2. MCP server configuration example in the configs
3. Documentation on SpendingPolicy patterns for autonomous agents

Happy to submit a PR if there's interest, or discuss the approach here first. The skill would follow ECC's existing skill format and conventions.

[affaan-m]

This is interesting, but payments are a high-risk capability and would need a much higher bar than an ordinary skill. I would not want wallet creation or autonomous spend enabled by default in ECC.

The minimum shape I would consider safe enough to discuss:

1. Skill/docs first, no bundled auto-enabled MCP.
2. Dry-run mode as the default.
3. Explicit human confirmation for every first real payment path.
4. Daily/per-transaction limits plus recipient allowlists.
5. No private keys or seed material stored in project repos.
6. Clear audit logs and receipts.
7. Tests for limit enforcement and failure modes.

A PR for an agent-payments skill could be useful if it is framed as security-first operator guidance and configuration review, not as a turnkey autonomous wallet. The contribution should assume payment credentials are sensitive production infrastructure.

[chenhz01]

Affaan-m's bar is right, and item 4 is the one that fails in practice: SPENDING_LIMIT_DAILY as a process env var is per-process state. Two concurrent sessions each get a fresh counter, and an npx restart silently resets the day, so the limit is advisory, not enforced.

Move enforcement out of the model and out of the process:

PreToolUse(send_payment): ledger.append(tx)   # SQLite, not memory
if ledger.daily_total() + tx.amount > CAP: deny

Dry-run stays the default and the first live path keeps the human confirmation. Available as a paid engagement too, if a delivered PR beats a review comment for you.