Why This Matters

If you’re building AI Agents, you’ll eventually hit one question: How does your Agent pay for things?

Here’s the scenario: your trading analysis Agent needs to call a paid API for real-time market data. The traditional approach is buying API keys upfront, setting up credit cards, manually managing quotas. But when you have 10, 100 Agents running at the same time, this model breaks down.

Agent Stack, released by Circle on May 11, 2026, solves this problem. It lets AI Agents:

  • Hold their own USDC wallets
  • Automatically discover needed services
  • Pay per use, settle instantly
  • All without human credit cards

Breaking Down the Four Agent Stack Components

1. Agent Wallets — Smart Wallets Built for Agents

Agent Wallets aren’t just dumping a regular wallet to an AI—they’re purpose-built for machine operations:

  • MPC technology: Private keys are split and stored distributively, never exposed. Even if an Agent gets compromised, the full private key can’t be extracted.
  • Spending policies: Set USDC spending limits per hour or per day—requests exceeding limits get auto-rejected.
  • Address controls: Whitelists (can only pay to these addresses) and blacklists (never pay to these addresses).
  • Cross-chain support: Operate across multiple chains via CCTP (Cross-Chain Transfer Protocol).

Here’s roughly how creating an Agent Wallet works in practice:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// Create an EOA wallet specifically for the Agent
const walletResponse = await circleDeveloperSdk.createWallets({
  accountType: "EOA",
  blockchains: ["EVM-TESTNET"],
  count: 1,
  walletSetId,
});

// Fund the testnet wallet via Circle Faucet
const response = await axios.post(
  "https://api.circle.com/v1/faucet/drips",
  {
    address: walletAddress,
    blockchain: "BASE-SEPOLIA",
    usdc: true
  },
  {
    headers: {
      Authorization: `Bearer ${process.env.CIRCLE_API_KEY}`,
    },
  }
);

Key point: Only EOA (Externally Owned Account) type wallets support transaction signing—this is the prerequisite for Agents to make autonomous payments.

2. Agent Marketplace — The Automated Service Vending Machine

Traditional API Marketplaces (like RapidAPI) are built for humans: you need to read docs, compare prices, manually integrate. Agent Marketplace is built for machines:

  • Structured service catalog that Agents can programmatically browse and evaluate
  • Each service shows USDC pricing
  • Compliance-first curation mechanism
  • Supports the full flow: Agent auto-discovers, evaluates, pays, and uses

Check out agents.circle.com/services to see what’s currently listed.

3. Circle CLI — Command Line Interface for Agents

Circle CLI is the interface for developers and AI Agents to operate the entire Circle platform via command line:

  • Create and manage wallets
  • Set spending policies
  • Discover services on Marketplace
  • Trigger transactions

Supports direct invocation from AI coding tools like Claude Code, Cursor, Codex, and OpenClaw.

4. Nanopayments — Making $0.000001 Transactions Possible

This is the part that gets me most excited. Powered by Circle Gateway, Nanopayments:

  • Zero Gas fees: Don’t worry about chain fees eating into micro-payment amounts
  • Minimum $0.000001: True sub-cent payments
  • Machine-speed settlement: Built for high-frequency M2M (Machine-to-Machine) transactions

This solves a long-standing pain point: traditional on-chain transaction Gas fees can exceed the actual payment amount, making micro-payments impractical. Nanopayments removes that cost layer entirely.

x402 Protocol: Making Payments as Natural as HTTP Requests

x402 is the payment core of the entire Agent Stack. Here’s how it works:

1
2
3
4
5
6
7
8

1. Agent sends GET /api/data request
2. Server responds with HTTP 402 Payment Required
   → Includes payment info: amount, recipient address, network
3. Agent signs payment authorization via Circle Signing API
4. Agent resends request with X-PAYMENT header
5. Server passes the signature to x402 Facilitator for verification
6. Facilitator confirms on-chain settlement
7. Server responds with HTTP 200 + data

The entire flow is Agent-autonomous, no human involvement needed. According to Circle, as of April 29, 2026, x402 processed $24.24 million in transaction volume over the past 30 days, with 99.8% settled in USDC.

Server-Side Integration (with x402-express)

If you want to enable x402 paywall on your own API, it only takes a few lines of code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import { paymentMiddleware } from "x402-express";

app.use(
  paymentMiddleware(
    recipientWallet.address,
    {
      "GET /api/risk-profile": {
        price: "$0.01",
        network: "base-sepolia",
      },
    },
    {
      url: "https://x402.org/facilitator",
    },
  ),
);

That’s literally all the code needed to turn a regular Express API into a pay-per-use API.

Real-World Use Cases

Use Case 1: Trading Analysis Agent

Your AI trading Agent needs real-time on-chain risk scores:

  1. Agent holds its own Circle Wallet with 10 USDC budget
  2. Agent finds a risk assessment service on Marketplace
  3. Each query auto-pays $0.01 USDC
  4. Spending policy caps daily spend at $1
  5. Fully automated—you just check the reports

Use Case 2: Content Generation Pipeline

Multiple Agents collaborate on content production:

  • Research Agent pays for market data ($0.005 per request)
  • Writing Agent pays for LLM API access ($0.02 per request)
  • Translation Agent pays for translation services ($0.01 per request)
  • Each Agent has its own wallet and spending limits

Use Case 3: MCP Server Monetization

You built an MCP Server and want to charge per use:

  1. Add paywall with x402-express
  2. List on Agent Marketplace
  3. Other developers’ Agents auto-discover, pay, and use
  4. Revenue goes directly to your USDC wallet

How Developers Can Get Started

Step 1: Get Your Circle API Key

Sign up for a developer account at developers.circle.com.

Step 2: Install Circle CLI

CLI is the fastest way to get started, supports direct use in AI coding tools.

Step 3: Create Your First Agent Wallet

Set up a wallet on testnet (Base Sepolia), fund it with test USDC via Faucet.

Step 4: Integrate x402

Add x402-express middleware to your API, or use x402-client to let Agents pay for other services.

Step 5: List on Marketplace

When your service is ready, submit it to Agent Marketplace so Agents worldwide can discover it.

What This Means for the AI Industry

Circle Agent Stack solves not a technical problem, but a business model problem.

Previously, AI Agents could only consume services via: API keys (manual management), subscriptions (fixed costs), or prepaid credits (capital sitting idle). Agent Stack makes “pay per use, instant settlement” possible—on-chain, in stablecoin, automated by machines.

The $24 million in 30-day volume proves this isn’t a concept proof—it’s infrastructure already in production.

For independent developers, this means you can turn any API into an automatic paid service—no Stripe, no credit cards, no account systems needed. Agent comes in, pays, gets data, leaves.

Want more AI Agent development实战 tips? Subscribe to the JudyAI Lab Newsletter for the latest articles.