Cloudflare on Aug. 4 formally introduced Cloudflare Wallets, a move aimed at giving AI agents something they have largely lacked: a way to pay on their own. Under the setup, an agent is no longer limited to calling APIs, reading data, or running code. It can hold an independent virtual wallet and, within preset budgets and permissions, use USDC and other stablecoins to buy APIs, data, content, and computing services.
That same week, a second path moved forward as well. On Aug. 6, MetaMask launched Agent Wallet, which lets an agent connect to an onchain wallet and carry out swaps, perpetual futures actions, prediction market trades, and liquidity management within limits defined in advance by the user.
These are different products, but they point to the same structural shift. AI agents are starting to gain the infrastructure needed not only to think or call tools, but to operate with budgets, payments, and asset permissions. The article frames this as one of the more important long-term changes in the current AI-crypto convergence.
What agents have been missing is not intelligence, but a payable account
Cloudflare’s case starts with a basic friction point. Agent systems and agent clusters have improved sharply this year, yet they still run into a familiar process when they need a paid service: find a provider, open the website, register an account, add a credit card, buy a plan, get an API key, and only then make the call.
For a person, that process is annoying. For software trying to complete a task autonomously, any step involving login, registration, payment, or identity verification can force a handoff back to a human. In other words, the “brain” of the agent has improved quickly, while much of the internet’s payment infrastructure is still built around human participation.
x402 is meant to change that. It revives the long-existing but rarely used HTTP status code “402 Payment Required” and places payment demands directly into the request-response flow.
Under Coinbase’s x402 design, when an agent requests a paid API, the server can respond with the required price, the assets it accepts, and where payment should be sent. After the agent pays and resubmits the request with proof of payment, the server verifies the result and returns the requested resource.
That changes the path from “register an account → add a payment method → preload funds or buy a plan → obtain an API key → call the service” to something much shorter: “make a request → receive a payment demand → pay → get the resource.” An account may not be needed. A subscription may not be needed. Nor does an agent have to buy a month-long or year-long package just to make a few calls.
On the surface, that sounds like a workflow cleanup. For AI agents, it is much more than that. The payment system they need is not one that pauses every time and asks an owner to enter a verification code. What fits better is a payment protocol that software can understand, execute automatically, and use for precise metering.
Stablecoins provide that settlement layer. Cloudflare’s current x402 developer documentation already supports machine-to-machine payments using onchain assets such as USDC. An agent requesting an API, an MCP tool, or other digital resources can pay directly instead of being pushed to a traditional payment page.
The pricing model for online content can shift as well. Much of the internet still relies on two standard choices: make content free, or put it behind a subscription wall that requires a human to register first. For agents, a different model looks more natural—charging per unit consumed, whether that means data used, API requests, compute used, or individual pages accessed.
That is why Cloudflare Wallets stands out. A research agent with a 10 USDC budget, for example, could compare price, speed, and quality across dozens of data sources. If one API costs only a few cents, it can test it immediately. If the result is poor, it can move on to the next one without asking for approval every time it spends a few cents.
What appears to be a restriction actually creates room for autonomy. If every 0.01 USDC payment has to be confirmed manually, the “autonomous agent” is still only a semi-automated tool. Once the user defines a clear budget boundary and keeps ultimate control outside that boundary, the agent can act freely inside it.
In that sense, Cloudflare Wallets reflects a deeper shift. The default economic actors on the internet used to be individuals and companies. Now parts of the underlying stack—from identity and payment to pricing—are starting to be redesigned for another participant: AI, or more specifically, the agent itself.
MetaMask pushes the question from buying services to using assets directly
If Cloudflare is focused on how an agent buys things, MetaMask Agent Wallet takes up the next issue: how an agent can use assets directly. It starts to put agents inside actual onchain operations, which is a different category from asking AI whether ETH looks worth buying.
Historically, the division of labor between a person and AI was fairly simple. AI gathered information, analyzed a problem, and offered suggestions. The person decided whether to act. In an Agent Wallet framework, an instruction can become something like: “If ETH drops near $3,000 and gas is below the average of the past 24 hours, buy 0.2 ETH.” The user supplies the goal, the conditions, and the permissions. Continuous monitoring, condition checks, trade preparation, and in some cases final execution can then be handed to the agent.
This is where “economic autonomy” becomes meaningful. It does not mean the agent owns property in its own right. It means the agent begins to have an account, a usable budget, and a set of economic permissions it can call on as conditions change. It can buy outside information and computing resources, and it can also move real assets to complete a goal within rules drawn by the user.
At the same time, that step links AI mistakes to direct economic loss for the first time. If a chat-only AI misunderstands a sentence, the result is usually a wrong answer. Once it has a wallet and execution rights, the same misunderstanding, prompt injection, or malicious tool call can become an irreversible onchain transaction.
That is why the article argues against handing an AI a wallet with unlimited permissions. Users can set daily spending caps, define which protocols may be used, and establish risk preferences in advance. Supported EVM transactions also go through transaction simulation, threat scanning, and MEV protection. If a transaction is flagged as abnormal, or if it exceeds a pre-set policy, automatic execution is paused and 2FA confirmation is required again from the user.
One principle follows from that setup: economic autonomy is not the same as unlimited authorization. A usable agent looks more like an employee with a company card and a defined job scope than someone holding the keys to the company safe. What it can buy, how much it can spend at once, how much it can spend per day, what it can decide on its own, and what requires escalation should all be defined before permissions are granted.
Seen from that angle, the core innovation of Agent Wallet is not merely that AI gets a wallet. It is that the industry is starting to deal systematically with how humans can delegate economic permissions to software without giving up control.
Wallets are moving from key storage toward permission management
Once the issue reaches that point, the wallet itself has to change. For more than a decade, the main job of a crypto wallet has been relatively stable: keep private keys safe. The interface could evolve, but the basic relationship stayed the same. A person initiated the action, reviewed the transaction, and approved the signature. The wallet’s primary responsibility was protecting the private key that determined ownership and final authorization.
Agents add another layer to that chain. Many actions no longer require the user to construct each transaction manually. The model starts moving from “a person directly operates assets” toward “a person states a goal first, then delegates part of the execution right to an agent.” That leaves wallets with a broader set of questions to answer:
- Who is allowed to use my assets on my behalf?
- Which assets can that entity use, and which protocols can it access?
- What is the maximum value of a single transaction, and how many times can it act in a day?
- What can it judge by itself, and when must it come back for confirmation?
- If the agent behaves abnormally, can I pause it immediately, revoke permissions, and recover funds?
For ordinary users, the central question is not just whether a wallet can automate tasks. It is whether these increasingly capable agents can be managed in a way that feels safe.
That is the layer imToken is focusing on around UI 3.0 and Agent Wallet. In its thinking about next-generation wallet interaction, one major change is a shift in user role from “Operator” to “Manager.”
In the old model, a transfer required the user to choose the network, input an address and amount, judge gas, and then review and sign step by step. In an intent-driven wallet, a user might only need to say, “Send 500 USDT to Frank.” The system can convert natural language into a structured intent, identify the recipient, amount, asset, network, and expected fee, and then return the final result for confirmation.
Less interaction, however, does not mean weaker control boundaries. The opposite is true. As more execution steps are automated by the system, the steps that disappear from the user’s view need to be constrained by clearer authorization mechanisms.
In imToken’s Agent Wallet design approach, each agent that receives execution rights is mapped to an independent agent account. Its session key is generated and isolated inside a trusted execution environment, or TEE, and the key does not leave that secure environment. At the same time, the agent account must be tied to a clear policy that covers protocol whitelists, single-transaction limits, daily limits, operating frequency, and validity periods.
So what the agent receives is not an unrestricted wallet. It receives an execution account fenced in by policy. The user retains a higher level of control and can adjust policy at any time, pause or resume the agent, revoke permissions, and withdraw funds. AI can help parse intent, plan routes, estimate fees, and flag risks, but the agent can execute only inside the policy range granted in advance. Anything outside that boundary has to return to the user for confirmation.
Just as important, authorization should not be a jump from zero to full trust. It should expand step by step. A newly used agent can stay first at the level of observation and analysis. As trust builds, it can move to giving suggestions and preparing transactions. The next step is execution after user confirmation. Only when the rules are explicit enough and risk boundaries can be controlled should the system move to autonomous execution within a strategy.
From L0 observation to L1 suggestion, L2 execution after confirmation, and L3 autonomous execution within policy, the article describes a progressive trust framework. An agent’s autonomy is not something the system should assume by default. It is something the user grants gradually.
Why users open wallets may change as well
This shift can also alter the reason people open a wallet in the first place. Today, entering a wallet usually means one of three things: checking balances, sending funds, or making a swap. If more routine actions are taken over by agents, the question may become different: what has my agent done recently, and is there anything that needs my attention?
The wallet’s core interface could move from an action panel to a management panel. At that point, the wallet is no longer just a place to store assets and initiate transactions. It becomes a permission control layer between a human and an agent acting on that human’s behalf.
That points to a change in the value proposition of wallets in the agent era—from “manage your private keys safely” to “manage your assets safely, along with the agents you authorize to use them.”
Autonomy grows, but final control still has to stay with humans
Over a longer time horizon, the article argues, AI agents gaining economic autonomy may become one of the most important structural changes to watch in this cycle of AI-crypto convergence. Smarter models and broader tool use still belong mainly to the information layer. Once agents have accounts, budgets, and asset execution ability, they begin to take part in real economic activity as active participants.
What determines whether agents can move into real financial use at scale may therefore be less about whether they are “smart enough” and more about whether a permission system can be built to match their capabilities. Autonomy always has an authorization side. In the agent era, wallets may not fade into the background at all. They may take on a larger role than they have today: making automation workable while keeping final control in human hands.
Letting an agent act is not the same as giving up control. That boundary may be the core question wallets need to answer before economic autonomy becomes a practical reality.