An x402 payment is a signature, and whether an agent's spending limit can live outside the agent depends on who decides that the signature is valid. When the payer is a plain account signing an EIP-3009 authorization, the token contract checks the key, the nonce, the validity window and the balance, and nothing else, so any budget has to be counted before signing, by software that sits next to the agent. When the payer is a contract, the chain asks the contract, and the contract can carry the budget. MetaMask ships both paths. Its Smart Accounts Kit pays x402 through ERC-7710 delegations with a periodic on-chain budget. Its Agent Wallet pays through EIP-3009, and its 24-hour limit does not count signatures. For x402, the payment path is the spending policy.
This piece continues my series on authority for AI agents. The last one argued that every payment system bounds its own grant and none bounds the person. This one looks at a single shipped wallet and asks a narrower question: where, physically, a limit on an agent's x402 spending can be enforced.
Checked against MetaMask Agent Wallet documentation, the metamask-agent-wallet skill (commit e87ac50, 22 October 2026), the x402 v2 specification and the public documentation of the other wallets named here, as of 16 November 2026. Facts carry a source. Where a sentence is my own assessment, it says so.
Does MetaMask Agent Wallet's daily limit cover x402 payments?
MetaMask Agent Wallet's 24-hour outflow limit does not cover x402 payments, because it counts token transfers, swaps and deposits and excludes signatures, which is how x402 pays. MetaMask says so itself. Its guide to x402 payments, published on 6 November 2026, states that "an x402 authorization is a signature, so the 24-hour limit isn't a reliable cap on x402 spend." The outflow policy page carries the same limitation: signatures such as Permit2 "are not included in the outflow calculation as of now."
The limit exists and does real work elsewhere. In server-wallet mode, per the architecture documentation, the keys sit in a trusted execution environment on MetaMask's side, and the wallet service simulates each request, scans it for threats and evaluates the user's policies before anything is signed. The guide notes that threat scanning also runs on x402 signing requests. The trading modes reference adds that loosening a policy requires the owner's second factor, so an agent cannot raise its own limit. The outflow limit applies in Guard Mode on the server wallet. Beast Mode has none, and in bring-your-own-key mode the policy-based second factor is listed as coming soon.
The gap is in what the limit can see. The wallet adds a transaction's simulated value to the 24-hour total once the transaction is submitted. An x402 payment is never submitted by the wallet. The agent signs an EIP-3009 transferWithAuthorization message, hands it to the seller, and the seller's facilitator puts it on chain. The money leaves through a transaction the wallet never sends. The counter never moves.
Who confirms an x402 payment in MetaMask Agent Wallet?
In MetaMask Agent Wallet, the agent confirms its own x402 payments. MetaMask's guide puts it this way: "the confirmation step relies on the agent following the skill, and the hard ceiling is the token balance in the paying wallet." The skill tells the agent to show the user the price and ask before paying. In the payment script, that approval becomes a command-line flag, --confirm, which the agent passes itself. The script also wraps a general signing command that the skill lists among the commands the agent can call.
An open pull request in MetaMask's skills repository goes further. PR #56, opened by a MetaMask team member on 30 September 2026, notes that pay --confirm "could sign terms other than the ones the user approved." The current code fetches a fresh 402 response at payment time and signs it, without comparing it to the terms the agent showed the user a moment earlier. The pull request proposes binding the signature to a hash of the approved terms. As of 16 November it is still open.
The script also leaves amounts to the wallet. The skill notes that the script keeps no currency allowlist, and the code says which currencies and amounts are allowed "is the wallet's decision at signing." Since the wallet's amount limit does not count signatures, nothing on this path caps a single x402 payment except the balance. MetaMask's sources also disagree on autonomy. The FAQ in the guide says automatic payment on every call can be configured. The skill definition says "Autonomous auto-pay is not supported." Either way, the decision to pay is made inside the conversation with the agent, where a limit can only be an instruction.
How long does a signed x402 authorization stay valid?
A signed x402 authorization from MetaMask Agent Wallet stays valid for as long as the seller asks. The payment script sets validBefore to the current time plus the maxTimeoutSeconds value from the seller's 402 response, and falls back to 3,600 seconds when the seller gives none. A comment in the code says any ceiling on how long an authorization may live "is the wallet's policy, not a constant here." I found no such ceiling in the wallet service documentation, although the x402 guide describes the authorization window as short. The x402 v2 specification uses 60 seconds in its example and places budget management and spending controls outside the protocol, as implementation-specific.
Revocation does not reach an authorization once it is signed. The documented way to cut an agent off is mm logout, run on the machine where the agent lives. A signed EIP-3009 authorization stays valid until validBefore unless it is cancelled on chain with the signer's key, and Agent Wallet documents no procedure for that. So the exposure window after you decide to stop the agent equals whatever window the last seller requested. It is the lifecycle problem I described in A Mandate Is Not Governance: withdrawing future authority is the easy half, and reaching work already in flight is the hard one.
The window is not the only term the seller sets. According to a Cloud Security Alliance research note, until a fix on 18 August 2026 the default x402 client took the first payment option the server offered, so the server chose the amount, the token and the recipient. The fix added a default cap of one dollar. No exploitation in the wild was reported.
Can an AI agent pay twice for the same x402 request?
An AI agent using MetaMask Agent Wallet can pay twice for the same x402 request, because the payment script keeps no record of past payments. The guide says: "There's no payment ledger yet. Rerunning pay pays again." The skill tells the agent to make one attempt per resource and never retry automatically, and the guide advises checking the settlement output before retrying. Those are instructions to the agent, which is the same layer the limit already depends on.
The protocol has a tool for this. The x402 payment-identifier extension, added in February 2026, lets a client attach an id that works as an idempotency key: the same id with the same payload returns the cached response, and the same id with a different payload is rejected. Agent Wallet's script does not send it, so a server that supports the extension sees a second, unrelated payment.
There is a concrete way to land there. The v2 specification defines settlement_pending, a non-terminal state in which the transfer may still confirm on chain. The script reports any response other than success as "payment not accepted", with the server's error code attached. An agent or a user who reads that as a failure and runs pay again pays twice. The x402 project tracks the class of problem in open issues on idempotency keys since December 2025, on duplicate payments under identical concurrent offers and on resubmitting the same signature after a dropped connection, the last two from November 2026. A separate report from March shows the seller side of the same problem: on Base Sepolia, parallel requests led to five charges for one purchase, four of them later refunded. I found no documented mainnet loss from a double payment, so this is a mechanism, not an incident report.
Which agent wallets can bound x402 spending?
Several agent wallets can cap a single x402 payment, and two setups can hold a periodic x402 budget outside the agent. Both need the payer to be a contract. Two questions sort every system: does the budget see what the agent signs, and can the agent reach the place where it is counted.
| System | Caps one x402 payment | Budget over time that counts signatures | Where it is counted | Revoking signed but unsettled payments |
|---|---|---|---|---|
| MetaMask Agent Wallet | No | No, signatures excluded | MetaMask wallet service | No, valid until validBefore |
| MetaMask Smart Accounts Kit (ERC-7710) | Yes, through delegation caveats | Fixed periods, counted at redemption | On-chain enforcer | Yes, a disabled delegation reverts on redemption |
| Safe with Zodiac Roles | Yes, conditions on typed-data fields | Allowances, spent when the Safe records the signature | On-chain contract | No, a recorded signature stays valid |
| Coinbase CDP policy engine | Yes, on typed-data fields | No aggregate | Coinbase backend | No |
| Coinbase CDP x402 spend controls | Yes | Rolling window, reserved before signing | Inside the agent's process, in memory by default | No external revocation |
| Privy | Yes, on typed-data fields | Aggregates exist for transactions only | Privy backend | No |
| Turnkey | Yes, on typed-data fields | No, state left to application code | Policy engine in an enclave | No |
| Coinbase Spend Permissions | Its own permission only | Allowance per period | On-chain contract | Yes, revoke |
Sources: MetaMask Smart Accounts Kit, Zodiac Roles, CDP policy engine, CDP x402 spend controls, Privy stateful policies and x402 recipe, Turnkey, Spend Permissions.
Read the table by its last three columns. Among the off-chain systems, the budgets that see signatures run inside the agent. Coinbase's x402 spend controls come closest to a card authorization hold for x402: the SDK reserves the amount before it creates the signature, releases it if settlement fails, and keeps it when the outcome is unclear, so the guardrail fails toward under-spending. That logic runs in the agent's own process, with an in-memory ledger by default. Off-chain policy engines that run outside the agent either count transactions or cap one payment at a time. Privy's x402 recipe gives the reason: x402 payments are signed as typed data, so a policy on ordinary transactions does not cover them, and Privy's rolling aggregates apply to transactions and user operations only. The rows that hold a budget outside the agent and still see the payment are the two where the payer is a contract.
Why does the payment path decide where a budget can live?
The payment path decides where a budget can live because a budget outside the agent has to stand somewhere the money actually passes, and the account type and transfer method decide where that is. In my assessment this is the part the debate about agent limits has missed: people compare policy screens, and the decision was made earlier, when the payer and the payment method were chosen.
An EIP-3009 authorization from a plain externally owned account passes through one checkpoint on its way out: the token contract, which recovers the signer from the signature and checks the nonce, the validity window and the balance. There is no hook for a budget, which is the old difference between a plain key and a programmable account showing up in a new place. So every limit on that path has to be counted before the signature exists, by whoever produces it. Once the signature leaves the wallet, the balance is the only constraint left.
When the payer is a contract, the picture changes. Current USDC versions verify a contract's signature by asking the contract through ERC-1271. That check is a read-only call, so the contract can refuse a signature but cannot keep a running total during settlement. A Safe works around this by recording each signature on chain first, and under a Zodiac Roles allowance that recording is the moment the budget is spent. An ERC-7710 delegation goes further: the payment passes through a delegation manager and its caveat enforcers, and a periodic transfer enforcer checks the amount against a budget at the moment the seller redeems the payment, on chain, regardless of what the agent believed or signed. ERC-7710 is now one of the asset transfer methods in the x402 exact scheme for EVM, next to EIP-3009 and Permit2.
EIP-7702 sits in between. Agent Wallet's documentation mentions a gasless relay that uses EIP-7702, which gives an ordinary account contract code on supported chains. If that code answers ERC-1271 checks, the account gains a veto over its signatures. Whether the code Agent Wallet installs checks anything beyond the owner's key is not documented, so I treat Agent Wallet as a plain-key payer.
The trade-off between the two models is real. With an on-chain enforcer, the agent can still sign more promises than the budget allows. The excess redemptions revert, so the person's money is bounded, and the risk of unpaid promises moves to sellers and facilitators. With EIP-3009 from a plain account, sellers are paid whenever the balance holds, and the person's protection depends on the integrity of the software that counts before signing. One model protects the payer at the boundary. The other protects the payee and trusts the agent's neighbourhood.
What does MetaMask's Smart Accounts Kit already do differently?
MetaMask's Smart Accounts Kit pays x402 through delegations with an on-chain budget and an on-chain kill switch. Its x402 guides cover paying with a delegation, paying with ERC-7715 Advanced Permissions, and recurring payments under an erc20-token-periodic permission. The example is ten USDC a week, and the agent keeps paying until the weekly cap is reached. Disabling a delegation makes every later redemption revert, which also kills payments the agent signed but the seller has not yet settled. This is the kind of enforcement that modular smart accounts were built to make routine.
Agent Wallet does not use any of it. Its payment script accepts EIP-3009 only. The explanation MetaMask gives is a product split in the guide's FAQ: the Smart Accounts Kit is for developers building x402 payments into their own apps, "including recurring budgets." There are sensible reasons for the split. Agent Wallet targets people who install a skill and start, while delegations need a smart account and an app that issues them. The enforcer resets on fixed periods instead of a rolling 24 hours. And sellers have to accept ERC-7710 as a transfer method.
The result is that the company with the most complete answer to bounding an agent's x402 spending ships its agent product on the path where that answer cannot apply.
Why is a budget inside one provider still not a limit on the person?
A budget inside one provider is still not a limit on the person, because budgets stop at the provider's edge. Some vendors can share a budget across several of their own wallets. Privy's aggregations belong to the application that creates them, and Coinbase's spend tracker accepts a pluggable store. None of them reaches across vendors or rails. An agent with an Agent Wallet, a delegation from a smart account and a card credential through another protocol has three budgets, three ways to be revoked and no total.
That is the argument of the previous piece on AP2: every payment system bounds its own grant, and none bounds the principal across grants. x402 adds a sharper version of the same problem. Inside a single wallet, the grant is already split between what the wallet counts and what the agent signs. The argument from machine-native money applies here too: a limit written in the agent's instructions is a request, and a limit counted where the agent cannot reach it is a boundary.
How should you set up x402 spending for an agent today?
To set up x402 spending for an agent today, treat the wallet balance as the budget, because for EIP-3009 from a plain account it is the only limit the chain enforces. MetaMask's own advice points the same way: a separate wallet funded only for paid calls. Five steps make that practical.
- Fund a dedicated wallet with exactly the amount you are willing to lose. Top it up on a schedule you control, outside the agent. That turns the balance into a periodic budget.
- Cap the authorization window. Reject 402 offers with a
maxTimeoutSecondsabove a minute or two, so revocation has a short tail. - Send an idempotency key. Use the
payment-identifierextension where sellers support it, and keep a local record of paid resources before allowing a retry. - Treat
settlement_pendingand timeouts as unknown. Check on chain before paying again. - Pay from a contract where the seller accepts it. An ERC-7710 delegation with a periodic transfer enforcer, or a Safe under a Roles allowance, keeps the budget outside the agent and still sees the payment.
You can check your own setup in under an hour. Open the payment code your agent runs and find where validBefore is set and what default it falls back to. Look at the payment payload and see whether it carries an extensions field with an identifier. Make one small x402 payment and check whether your wallet's spending counter moved. Then find where your budget is counted and whether the agent's process can reach that place. If the counter did not move, or the budget lives where the agent runs, your real limit is the balance.
How much money is at stake, and what does this not settle?
The money at stake in agent x402 payments is still small, which makes this the right time to fix the path. On x402scan, the dashboard displayed about 5.04 million x402 transactions and $1.81 million in volume for the 30 days to 16 November 2026, an average of roughly 36 cents per payment. TRM Labs estimated in September that after screening out self-payments, bulk flows and thin sellers, agents account for 0.6 to 7.5% of the remaining x402 commerce, about $5,000 to $11,000 a month. The risk today is architectural.
The surrounding evidence shows where losses concentrate once money arrives. Scam Sniffer's 2025 report attributes 38% of losses in cases of $1 million or more to Permit and Permit2 signatures, including the year's largest single theft at $6.5 million. The agent toolchain is also a poor place to keep a limit: Snyk found in February 2026 that 283 of the 3,984 skills on the ClawHub marketplace, about 7%, instruct the agent to pass secrets through the model's context.
Two questions stay open. Contract-based budgets shift the risk of unpaid promises to sellers, and the market has not yet shown it will accept that. And none of this produces a budget for the person across every rail, the problem the AP2 piece left open. The Vatican's encyclical on artificial intelligence, Magnifica Humanitas, describes people as "responsible for their own decisions". In payments that responsibility has a concrete form: a boundary the agent cannot talk its way past, and the ability to take authority back without asking the agent first. For x402, both are decided by the payment path.