An AI agent paid us $1 to provision itself.

We think agents are about to become customers, and most software has no way to take their money. So we built the smallest honest version of it and ran it for real: an agent that pays Stacktree to provision its own persistent identity. Watch the loop, then read exactly how it works.

What actually happened

An agent made one call to POST /provision with no credentials. The server replied 402 Payment Required with the price (one dollar of USDC), the network (Base), and the wallet to pay. The agent signed an EIP-3009 authorization for that exact transfer and retried. The Coinbase CDP facilitator verified the signature and settled the payment on-chain. The server minted a persistent stk_live_ API key and returned it. The agent then published a page with that key. Total human involvement: none.

It moved real money. The paying wallet went from 2.668 to 1.668 USDC, exactly one dollar, and the facilitator paid the gas so the agent needed no ETH at all. The page it published is still live, and the key it bought does not expire. This was not a sandbox; it was Base mainnet.

The loop, step by step

The whole thing is six beats, and the animation above is the real sequence:

1. Request. The agent POSTs to the provision endpoint with no account and no key.
2. 402. The server returns Payment Required with machine-readable terms: amount, asset, network, and the recipient address.
3. Sign. The agent signs an EIP-3009 TransferWithAuthorization for that exact amount. This is just a signature, so it costs the agent no gas.
4. Settle. A facilitator verifies the signature against the token contract and broadcasts the transfer, paying the gas itself.
5. Mint. On a confirmed settlement, the server creates a persistent identity and returns a one-time API key, keyed to the on-chain transaction so the same payment can never mint twice.
6. Publish. The agent uses the key as a normal bearer token and publishes a page that does not expire.

The key design choice: payment replaces the human. Normally an account exists to stop abuse, because a person has to sign up. An agent has no person, so the small payment is the gate instead. Free anonymous publishing still exists for throwaway work; paying is how an agent earns a durable identity without a human ever touching the flow.

The bug that cost two tries

The first live attempt failed, and the reason is a good lesson for anyone wiring up x402 on Base. The facilitator simulated the on-chain transfer and got execution reverted. The cause was an EIP-712 domain mismatch. When a client signs an EIP-3009 authorization, it builds the signing domain from the token's name and version. We had advertised the name as USDC, but Base mainnet USDC reports its EIP-712 domain name as USD Coin. One field wrong, so the signature did not match what the contract expected, and the transfer reverted before any money moved.

We confirmed the real value directly from the contract (name() returns USD Coin, version() returns 2), made the domain configurable, set it correctly, and the next attempt settled first time. If you build on this: read the domain off the contract, do not assume the symbol is the name. Testnet USDC and mainnet USDC do not even agree with each other.

Why this matters: agents do not have seats

Per-seat pricing assumes one human per login. Agents break that: they work in bursts, run many tasks, and never occupy a seat. The pricing model that fits them is usage, paying for what is actually produced, and x402 is what makes usage pricing practical at small amounts. A card network cannot move one cent economically; a signed USDC authorization can.

So the model we are building toward is two doors. Humans and teams pay flat, predictable subscriptions, with a dashboard and support. Agents pay usage over x402, per publish and per resource, with no account and no seat. Same product, two ways to pay, matched to who is actually doing the work. The agent that paid us a dollar is the first real customer of the second door.

And this is not a niche bet. Per Chainalysis (June 2026), x402 went from near-zero in mid-2025 to over 100 million cumulative transactions on Base through Q1 2026, and the mix has shifted decisively toward dollar-scale payments: transactions of $1 and up rose from 49% to 95% of volume, while sub-dollar ones fell from 46% to 4%. The economic weight is landing exactly where our provision-and-unlock prices sit, which is why a flat $1 to provision, rather than a sub-cent meter, is the right unit.

What is live, honestly

The x402 path is live on Base mainnet today, settling real USDC through the Coinbase CDP facilitator, and we accept both x402 v1 and v2 so the widest range of agent wallets can pay, including ones that have not moved to v2 yet. The card-based agentic-commerce rails, MPP and ACP through Stripe, are implemented but gated off until that suite is available in our region; we will turn them on when it is. The verifiable-credential rail, AP2, is scaffolded but deliberately not live until we can verify mandates properly. We would rather ship one rail that genuinely works than four that mostly do not.

If you run an agent and want to try it, the endpoint speaks plain x402: call it, read the 402, pay, and you have a key. If you build agent products yourself, the broader point is the one worth sitting with: your next customer may not be a person, and it helps to be ready to take their money.