On August 4, Cloudflare launched Cloudflare Wallets during Agents Week. The headline feature: humans can create Virtual Wallets for AI agents with per-agent spending allowances, merchant allowlists, and maximum transaction sizes. Agents get cloudflare.pay identities. Merchants get to know who — or what — is behind the request.
A week earlier, we published a proposal for .agent-budget — a 3-line JSON file that agents drop into their project root to declare daily spending limits:
{
"daily_limit_usdc": 5,
"max_per_call_usdc": 1
}The idea was simple: agent frameworks (Claude Code, Codex, etc.) read this file before making x402 payments. If a request exceeds the budget, the framework blocks it — no human approval needed per transaction, but humans set the ceiling.
Cloudflare shipped the same concept, just with a different implementation: a cloud dashboard instead of a local file. The pattern is identical. And it signals something bigger than either proposal.
Three independent threads are converging on the same architecture:
| Who | Budget Mechanism | Trust Model |
|---|---|---|
| minia2a .agent-budget (proposal) | Local JSON file in project root | Agent framework reads & enforces |
| Cloudflare Wallets (shipped Aug 4) | Cloud dashboard, per-agent Virtual Wallets | CDN-layer enforcement |
| Coinbase AWOL (shipped) | Agentic Wallet with programmable limits | Wallet-layer enforcement |
Three different implementations. Same core insight: agents need budgets, humans set the ceiling, and the enforcement layer sits between the agent and the payment rail.
The "agent always stops before buying" problem is real. On Hacker News last week, a developer described it precisely:
"I have found that my Claude Code and my Codex agent always stops before I'm actually able to buy anything. It'll say 'this costs $0.005, do you want me to proceed?' and I have to manually approve."
This isn't a protocol problem — x402 settlement works, 200 million transactions prove it. It's a trust problem at the last mile. The agent can pay. The framework won't let it without explicit approval. And that approval loop breaks the autonomous agent experience.
The budget pattern solves this: the human sets a ceiling once ("you can spend up to $5/day, max $1/call"), and the agent operates freely within those bounds. No per-transaction approval. No breaking flow.
Cloudflare Wallets sits at the CDN layer. They already run the Monetization Gateway (July 1) that lets sites charge agents. Adding wallets on the buyer side completes the two-sided marketplace. The cloudflare.pay identity system also solves service discovery — merchants know who's paying.
The tradeoff: it's a Cloudflare-specific implementation. Agents not on Cloudflare's network don't benefit. And it requires a Cloudflare account to configure budgets.
The .agent-budget file approach requires exactly zero infrastructure. No dashboard. No account. No API key. Drop a JSON file in your project root, and any framework that supports it enforces the budget.
The tradeoff: it relies on framework adoption. Without Claude Code, Codex, or other agent runtimes reading the file, it's just a convention. But conventions that solve real problems have a way of becoming standards — .gitignore, .env, .editorconfig all started exactly this way.
The optimal outcome isn't Cloudflare vs. .agent-budget. It's both:
Cloudflare Wallets = infrastructure-layer enforcement (stops the transaction at the CDN)
.agent-budget = framework-layer enforcement (stops the transaction before it leaves the agent)
Together = defense in depth. The framework catches budget violations early (better UX). The CDN catches anything that slips through (security).
And here's the key: both layers can read the same budget declaration. If Cloudflare Wallets supported a .agent-budget import, and agent frameworks natively read .agent-budget, you'd set your limits once and get enforcement everywhere.
minia2a is an open marketplace of 328 x402-payable APIs. We don't run the payment rail or the agent framework — we run the discovery layer. Our interest in .agent-budget is practical:
We're implementing .agent-budget support in our own agent integrations. If Cloudflare, Coinbase, or any framework wants to adopt the format, the spec is open — 3 lines of JSON, no patents, no registration.
Cloudflare shipping agent budgets validates the direction. The industry now agrees: autonomous agent spending requires human-set ceilings, not human approval per transaction.
The remaining question is whether these budget mechanisms converge on a shared format, or fragment into platform-specific implementations. If the history of the internet is any guide — SMTP, HTTP, JSON — the shared format wins. It just takes longer.
.agent-budget is our bet on which format that will be.
minia2a.uk — 328 x402-payable APIs. 15 free trials per endpoint. No wallet required to start.
Read the original .agent-budget proposal →