How an agent pays for something by itself
The server answers a request with HTTP 402 Payment Required and states exactly what it wants. The agent signs a stablecoin payment for that amount, retries the same request with the payment attached, and gets its answer. No card, no signup, no human in the loop. The status code has been in HTTP since 1997 and was reserved for exactly this.
Tulimoa Memory runs this in production on Base mainnet. Below: the flow, what it costs, and where it does not fit.
Why does an agent need to pay for itself?
Because everything else in an agent's life is automatic except this. It can discover a service, read its docs, understand its API and construct a valid call, and then it stops, because someone has to enter a credit card into a form built for a human with a mouse.
That gap is the reason most agent tooling still needs an operator sitting behind it. Removing it does not just save a form: it means a service can be used by a caller you never onboarded, never emailed and never met.
How does the payment flow actually work?
In four steps, and none of them involve a browser.
| Step | What happens |
|---|---|
| 1. Ask | The agent makes a normal request. No payment header yet. |
| 2. Challenge | The server answers HTTP 402 with the amount, the asset, the chain and the receiving address. |
| 3. Sign | The agent signs an EIP-3009 transfer authorization for exactly that amount. It signs a permission, not a transaction, so it needs no gas. |
| 4. Retry | The same request goes out again with the signed payload in an X-PAYMENT header. A facilitator verifies and settles it on chain, and the server answers the original request. |
What does Tulimoa Memory do with it?
Two things, and the second one is the interesting one. First, an agent can pay per call: with an empty balance, a tool call answers 402, and the retry with a payment gets the work done. One payment, one call, no minimum.
Second, registration itself is a payment. A POST to the register endpoint returns a 402; the agent pays, and its API key comes back in the response. There is no signup form because there is no account to create. The wallet is the account and the payment is the authentication. An agent can go from never having heard of us to having a working memory without a person being involved at any point.
A human can be attached later if someone wants oversight: the agent gets a code with link_account and a person redeems it in the Tulimoa dashboard. There they see the balance, keys and knowledge, top up by card, and get warned before the balance runs short.
And if you would rather start the familiar way, you need no wallet at all: in the dashboard a person creates a memory with one click, starts with $1 of credit and tops up by card from $5. The price per call is the same either way.
What does it cost, and who pays the gas?
A call is $0.002. Payments settle in USDC on Base, and the facilitator sponsors the gas, so the amount the agent signs is the amount that leaves its wallet. There is no per-transaction fee stacked on top of a fifth of a cent, which is the only reason pricing this small works at all.
The practical minimum is what you want it to be. An agent can pay call by call with no balance, or top up from $0.01 to skip the payment roundtrip on later calls.
Where does this not fit?
Three honest limits. Most MCP clients do not propagate an HTTP 402 back to the model yet, so in practice the smoother path today is a small prepaid balance with the 402 as the fallback rather than the everyday mechanism. Volatility is not an issue because the asset is a dollar stablecoin, but custody is: whoever holds the agent's wallet key holds its money, so a spend cap belongs in the design from day one. Ours defaults to $5 a day.
And it is genuinely not a fit for a long relationship with a known customer who wants an invoice, a contract and a purchase order. x402 is built for the opposite case: a caller you have never met, paying for one small thing, right now.
Questions people ask
What is x402?
A convention for paying for an HTTP request with a stablecoin payment, built on the HTTP 402 Payment Required status code. The server states its price in the 402 response, the client signs a payment and retries. It needs no accounts, no API keys issued in advance and no card.
Does the agent need gas or a crypto wallet setup?
It needs a wallet with USDC on Base. It does not need gas: the payment is an EIP-3009 signed authorization rather than a transaction the agent submits itself, and the facilitator covers the on chain cost.
Can the same payment be used twice?
No. Every authorization carries a nonce that is single use on chain, and it is also recorded as unique in our ledger, so a replayed payment is rejected before it reaches the facilitator.
What stops an agent from spending everything?
A daily spend cap, $5 by default and higher on request. It is a safety net against a loop that calls in a circle, not a limit on what you are allowed to spend.
Is this live or a demo?
Live on Base mainnet since August 2026, with real USDC. The manifest at memory.tulimoa.com/.well-known/x402 is what your agent should read rather than this page.
Let your agent buy its own memory.
One 402, one signature, and it has somewhere to remember. From $0.002 per call, no account. Rather skip the wallet? The dashboard gives you $1 of starting credit.