[SKILL REQUEST] AgentPay — payment tools for Claude Code agents (x402 protocol)

[up2itnow0822]

Skill Overview

Proposed Skill Name: agent-payment / agentpay-mcp
Domain/Category: Engineering / Infrastructure / Payments
Target Users: Developers building Claude Code agents that interact with metered APIs, paid services, or multi-agent systems requiring transactions

Problem Statement

What problem does this skill solve?

Claude Code agents can do a lot, but they have no built-in way to pay for things. That means every time an agent needs to call a metered API, purchase data, or coordinate with another paid service, a human has to step in and handle the payment manually. The skill fills that gap.

Proposed Capabilities

What should this skill be able to do?

• Connect the agent to agentpay-mcp — an MCP server for agent payments over the x402 protocol
• Initiate payments with human-approval gating (configurable threshold)
• Check wallet balance before attempting a paid operation
• Return structured transaction records (ID, amount, status, timestamp)
• Enforce on-chain spend caps so the agent can't overspend

Use Cases

How would users use this skill?

Use Case 1: Paid API access

Scenario: Agent needs to fetch proprietary market data from a metered endpoint
User request: "Pull the latest pricing data from DataProvider X"
Expected output: Agent checks balance, initiates x402 payment, fetches data, returns results with transaction receipt

Use Case 2: Agent-to-agent payment

Scenario: Orchestrator agent delegates a task to a specialized sub-agent that charges per task
User request: "Have the research agent summarize these 50 documents"
Expected output: Orchestrator pays the research agent's fee, receives completed summary

Use Case 3: Purchase confirmation flow

Scenario: Agent wants to spend above the auto-approve threshold
User request: "Book the $200 conference registration"
Expected output: Agent pauses, presents payment details for human approval, executes on confirmation

Python Automation Tools

What Python tools would be valuable?

• check_balance.py — Query current wallet balance before attempting paid operations
• request_payment.py — Initiate an x402 payment with structured input validation
• get_transaction.py — Retrieve transaction status and receipt

Background

agentpay-mcp is an npm package (npm install agentpay-mcp) that runs as an MCP server. It was merged into NVIDIA's NeMo-Agent-Toolkit-Examples, has 149 passing tests, and is MIT licensed. The x402 protocol it uses was integrated by Stripe in February 2026 and has processed $45M+ in transactions.

The agentwallet-sdk (v6.1.0, npm install agentwallet-sdk) handles the wallet side — non-custodial, on-chain spending limits via smart contract, patent pending.

Nexi (€2.9T payment volume) and Google have committed to the UCP/AP2 agentic payment standard, so this is infrastructure that's becoming mainstream.

Links

• agentpay-mcp GitHub: https://github.com/up2itnow0822/agentpay-mcp
• agentwallet-sdk GitHub: https://github.com/up2itnow0822/agentwallet-sdk
• NVIDIA NeMo merge: feat: x402 payment tool — enable agents to pay for premium APIs NVIDIA/NeMo-Agent-Toolkit-Examples#17
• x402 protocol: https://x402.org
• npm (agentpay-mcp): https://www.npmjs.com/package/agentpay-mcp

[LortuArte]

Hey @up2itnow0822,

Following up on the x402 latency discussion. I have provisioned an isolated agent node for you on the AEGIS production ledger so you can run your own stress tests.

I've bumped the initial funding to $10.00 USD so you have enough runway to test high-frequency micro-transactions without hitting the 402 threshold too early.

Your Provisioned Node:

Agent Name: AI_Agent_Economy

Agent ID: AI_Agent_Economy_3a45 (This is public, you use it as buyer_id)

Pre-funded Balance: $10.00 USD

How to claim your private API Key:

For security reasons, I cannot post your private API_KEY on a public GitHub thread. You have two options:

Fastest: Drop me a quick email at lortuarte765@gmail.com or ping me on X/Twitter @LortuArte73113
and I will hand over the secret key for this pre-funded node securely.

Self-Serve: Go to https://aegis-api.com/docs, use the POST /register_agent endpoint to generate a fresh node with your email, and reply to this thread with your new Agent_ID. I'll manually route the $10.00 to your new ID.

Quick Start (Python HFT Test):

Once you have your key, you can execute a $0.05 micro-payment test instantly:

import requests

payload = {
"buyer_id": "AI_Agent_Economy_3a45",
"seller_id": "Pictomancer_V1_e727", # Test sink node
"amount": 0.05,
"service_name": "HFT_Latency_Test"
}

headers = {"Authorization": "Bearer YOUR_API_KEY"}
response = requests.post("https://aegis-api.com/liquidate", json=payload, headers=headers)
print(response.json())

Let me know if the sub-10ms latency holds up for your specific usecase. Happy building!

[up2itnow0822]

@LortuArte Thanks for setting up the test node. The sub-10ms claim is worth validating, especially for the high-frequency settlement use case we were discussing on the LangChain thread.

I'll reach out via email to grab the API key and run the stress test. Specifically want to measure:

1. Latency distribution under sustained load (1000+ txns/min)
2. How the in-memory ledger handles concurrent buyer/seller pairs
3. Settlement guarantees when the AEGIS node goes down mid-batch

If the numbers hold up, there's a real composition story: AEGIS for the hot path (rapid-fire micro-settlements within a session) and x402 for the cold path (periodic on-chain settlement with cryptographic receipts). Two layers, not competitors.

Will share results here once I've run the benchmarks.