Author: Stablehunter

Recently, infrastructure surrounding Agentic Payments has begun to emerge in large numbers.

Tempo launched its mainnet, and Stripe and Tempo jointly launched the Machine Payments Protocol (MPP); Visa is advancing Visa Intelligent Commerce and the Trusted Agent Protocol; Google launched the Agent Payments Protocol (AP2) and continues to extend towards the Universal Commerce Protocol (UCP); Coinbase also released Agentic Wallets and x402, attempting to provide native wallets and payment capabilities for AI agents. In other words, payment protocols, identity trust layers, commerce standards, and agent wallet layers surrounding Agentic Payments are all emerging simultaneously.

As this infrastructure begins to emerge, the industry's description of the endgame is getting closer and closer.

In the future, AI agents will not only help people search, recommend, and place orders, but will also directly complete transactions, payments, and settlements on behalf of users or businesses within authorized boundaries. The initiator of payments will also gradually shift from "human manual confirmation" to "machines executing according to rules." The recent public statements by Visa, PayPal, and OpenAI regarding agency commerce are essentially moving in this direction.

The endgame has been pretty much discussed by everyone. But the biggest uncertainty now isn't whether the endgame even exists, but which layer will be validated first. Even OpenAI, a platform closest to the traffic entry point, is still adjusting how to implement "direct checkout," which shows that industry consensus has been reached, but the implementation path is far from finalized.

The real question worth studying is no longer what the future will look like, but rather: how will the road be laid out from today to where we are?

Because payment is not a search, recommendation, or order placement. The real difficulty in payment has never been "whether it can be initiated," but rather "whether it can be authorized, constrained, audited, and held accountable."

Therefore, this article doesn't want to repeat the final outcome of Agentic Payment. Instead, it wants to break it down: from "human confirmation" to "automatic machine payment," what layers will emerge first, and what key nodes will be blocked?

I. Agentic Payment will not be implemented all at once; it will definitely be rolled out in stages.

Many people now talk about Agentic Payments with the assumption that it will happen naturally as long as the model is smart enough and the payment interface is open enough.

However, payment is never simply a matter of capability; it's a matter of trust. AI can certainly learn quickly to search, compare, place orders, and call APIs, but this doesn't mean the system will allow it to directly control the flow of funds. Payment involves more than just the action itself; it also includes authorization, responsibility, risk control, compliance, and settlement. Therefore, Agentic Payment cannot jump directly to a state of "payments executed entirely by machines"; it is more likely to unfold along a path of gradually releasing permissions.

In other words, the real question isn't "when will AI start making payments," but rather: under what conditions will humans gradually relinquish the power of payment to machines? If we break this process down, it will roughly go through five stages.

Phase 1: AI participates in decision-making but does not handle payments.

This is the earliest and most readily accepted stage. The AI agent first enters the pre-transaction process, helping users complete searches, filtering, recommendations, price comparisons, and order preparation, but the final payment step is still confirmed by a human.

Many public demonstrations of Agenda Commerce today are essentially still at this stage: AI can push the purchase process very close to completion, but the actual payment confirmation remains in human hands. When explaining Agenda Commerce to consumers, PayPal also explicitly states that "users can request confirmation before purchasing" as a standard practice.

The reason this step happens first is simple: it has the least impact on the existing payment system. Merchants don't need to completely overhaul their systems, and the payment network doesn't need to immediately rewrite its authorization logic. AI is simply upgrading from a "recommendation tool" to a "transaction orchestration tool."

However, its boundaries are also clear: AI can help you get to the point of payment, but it has not yet actually obtained the right to pay.

Phase Two: AI can trigger the transaction process, but humans retain the final confirmation right.

Taking it a step further, AI doesn't just offer suggestions; it can directly drive the transaction process. It can create orders on your behalf, call merchant interfaces, prepare payment parameters, and even push the purchase to the final step before confirmation.

This will be a very long transition period because it balances efficiency and security. Users are beginning to accept "AI helping me complete processes," but they haven't yet accepted "AI deciding how to spend money."

Visa's latest moves surrounding Intelligent Commerce and the Trusted Agent Protocol are essentially paving the way for this transition: enabling merchants to identify trusted AI agents while still maintaining transactions on a controlled and verifiable authorization mechanism. Visa defines the Trusted Agent Protocol as a core component of Intelligent Commerce, focusing on enabling merchants to identify and verify "trusted agents with genuine transaction intentions."

Why is this step important? Because it begins to transform payments from "manual human operation" to a "programmable machine process." But it still hasn't completed the most crucial leap: machines haven't yet gained persistent payment permissions.

Phase Three: AI obtains authorized limits within limited boundaries

This is the first real turning point. At this stage, people no longer confirm each transaction individually, but instead define rules first and then let the machine execute within those rules. Authorization begins to shift from "action authorization" to "policy authorization".

For example, users or businesses can stipulate that: you can only pay within your monthly budget; you can only pay to whitelisted merchants; you can only purchase specific categories of goods; you must confirm again if the amount exceeds a certain amount; and certain payments can only occur within a specified time window.

At this point, AI is not granted "free payment rights," but rather a constrained right of execution. For the first time, the core of Agentic Payment has shifted from "intelligent assistant" to "machine agent."

When Google launched AP2 in 2025, it explicitly defined it as an "open protocol for securely initiating and executing agent-led payments across platforms." Then, in January 2026, Google launched UCP, positioning it as an open standard for aggregator commerce and emphasizing its compatibility with AP2. This evolution itself demonstrates that the industry is understanding "AI payments" as a complete system of permissions and processes, rather than a single payment API.

Therefore, what is truly important at this stage is not who creates an AI payment button first, but who develops a machine authorization system into a product first.

Phase 4: AI possesses natively usable wallets or payment accounts.

At this level, things begin to change significantly. In the previous stages, AI was essentially still "using human payment tools on behalf of humans." But in this stage, AI is no longer just accessing a card, a wallet balance, or a checkout entry point; it begins to possess a more native fund container. It can hold, receive, allocate, and spend funds under clearly defined rules, and its payment capability upgrades from a checkout action to a continuous fund management capability.

When Coinbase launched Agentic Wallets in February 2026, its definition was straightforward: it's a wallet infrastructure specifically built for AI agents, supporting autonomous spending, earning, and trading. x402 is placed at the core of this system as a payment protocol for autonomous AI use cases. The official statement also emphasizes that x402 has already been validated in scenarios such as machine-to-machine payments, API paywalls, and programmatic resource access.

The significance of this step is that the economic behavior of agents is no longer just "completing a purchase on behalf of someone," but has begun to possess the ability for continuous income and expenditure and resource allocation. Payment has thus transformed from a front-end consumption behavior into an account capability within the machine economy.

Phase 5: Continuous machine-to-machine transactions become the new normal

This is the endgame that everyone likes to talk about today, and it's also the stage that's easiest to imagine but hardest to fully implement all at once. In this stage, the two parties to the transaction may no longer be "people" in the traditional sense. It could be one agent paying API fees for another agent, an enterprise system automatically replenishing its cloud resource quota, or real-time settlement when a model calls another model, a device calls a service, or a workflow calls a data source.

The characteristics of this type of payment are clear: small amounts, high frequency, automation, cross-system, 24/7, and often inherently cross-border. Because of this, its requirements for underlying infrastructure differ from those of traditional human payments.

The launch of the Tempo mainnet and the introduction of MPP are building a foundation around this layer: Tempo clearly positions itself as a payments-focused L1, while MPP is defined as an open standard for machine payments, supporting payment methods such as stablecoins and cards; Stripe's official documentation also directly describes MPP as "an internet payment protocol for machine-to-machine payments".

While the endgame has been clearly outlined, it doesn't mean it's already fully unfolding today. A more realistic assessment is that the industry is progressing from the first and second stages to the third and fourth, with the fifth stage still appearing to be a gradual approach. Coindesk's March 2026 report on x402 even directly pointed out a real problem: technology is advancing, but real demand and large-scale usage haven't fully caught up.

Before delving into the specific players involved, let's first take a more comprehensive look at the infrastructure of this round of Agentic Payments. You'll find that while it looks bustling, it's not actually about doing the same thing, but rather about different layers advancing simultaneously.

Agentic Payment is not a single product, but rather a complete infrastructure stack that is emerging simultaneously. From protocols, identities, and standards to wallets, settlement, and currency layers, the key pieces of the Agentic Payment puzzle are already taking shape in the hands of different players.

II. The agentic payment poker tables are set up, but each player is betting on a different card.

Once you break down these five stages, it becomes easier to understand why everyone is talking about Agentic Payment, yet their actions seem quite different. They're not betting on the same level.

Stripe / Tempo: Betting on "Machine Payment Protocol + New Clearing Platform"

On the Stripe and Tempo side, the most noteworthy aspect is not the actions of any single product, but their attempt to occupy two layers simultaneously: the upper layer of machine payments protocol and the lower layer of machine-native settlement rail.

MPP is the protocol layer, attempting to define how agents and services initiate, accept, and coordinate automated payments; Tempo is the foundation layer, attempting to address the cost, confirmation speed, and scalability requirements of such payments. Since the Tempo mainnet launch, the official statement has been very clear: if stablecoins become the core layer of internet commerce, the infrastructure for mobile money needs to be specifically built for payments, not for general on-chain computation.

In other words, Stripe/Tempo's journey is not just about creating "payment functions that AI can also use," but rather a bet that the machine economy will require a more native payment protocol and clearing layer.

Visa: Betting on "Trusted Agent Identity + Merchant-Side Access Order"

Visa's approach differs from Stripe/Tempo. Instead of starting with a new blockchain or wallet, it addresses a more practical issue: as more and more AI agents access merchants and complete purchases on behalf of users, how can merchants distinguish between "trustworthy agents" and "malicious bots"?

Trusted Agent Protocol and Visa Intelligent Commerce are essentially answering this question. Visa aims to secure the most crucial yet easily overlooked layer of aggregator commerce: the trust layer and the order of merchant access. Judging from Visa's public statements, its goal is not simply to add an AI payment button, but to maintain an identifiable, verifiable, and traceable transaction relationship between merchants, card issuers, and consumers. Visa seems to be focusing on the second and third stages: first transforming agents into "trusted transaction participants," and then gradually moving towards controlled authorization.

Google: Betting on "open commerce standards + cross-protocol harmonization"

Google's position is somewhat unique. Looking at AP2 and UCP together, what it truly aims to achieve isn't single-point payments, but rather an open language layer for agency commerce. AP2 addresses how agent-led payments are securely initiated, while UCP addresses how consumer surfaces, businesses, and payment providers can share a common set of commerce primitives. Google's official definition of UCP is also straightforward: it's an open-source standard for next-generation agency commerce, compatible with AP2, and designed to work seamlessly with existing retail infrastructure.

This means that Google is betting on a middleware standard: it doesn't necessarily process every payment itself, but it hopes to define a public syntax for "how agents understand goods, merchants, payment capabilities, and transaction processes."

In terms of its approach, Google seems to be focusing its efforts around the third stage: it is helping the industry standardize "machine licensing" and "cross-platform transaction collaboration".

Coinbase: Betting on the "Agent-based native wallet layer"

Coinbase doesn't start by discussing merchant onboarding or open commerce protocols; instead, it focuses directly on the agent's fund container.

The logic behind Agentic Wallets is clear: if there are increasingly more machine-native transactions in the future, then the agent itself will need a programmable, constrained, spending, and receiving native wallet layer. The x402 acts as the payment protocol, while the wallet provides the account capabilities. Coinbase officially describes this product as enabling agents to "spend, earn, and trade."

Therefore, Coinbase is actually betting on the fourth and fifth stages: not to first enable AI to better integrate with human payments, but to first enable AI to have its own executable account system.

Circle/Tether: They haven't made a protocol, but they are defining "what money the machine uses".

If we break down the players in this round by one layer, we'll find an easily overlooked position: Circle and Tether. They haven't directly launched an Agentic Payment protocol, nor have they created a public chain specifically for AI agents, but they are constantly strengthening a more fundamental capability—making money itself accessible to programs.

In its public statements over the past period, Circle has repeatedly emphasized programmable money and API-based payments. In March 2026, Circle launched the Nanopayments testnet, directly describing it as one of the core primitives of "agentic economic activity," supporting gas-free USDC transfers as low as $0.000001.

Essentially, it answers the question: when the initiators of transactions begin to change from "people" to "machines," does money itself also need to become a callable infrastructure?

If we say:

Stripe defines the "payment protocol".
Visa defines "who can pay" (identity/trust).
Google defines "how transactions are understood" (commerce standard).
Coinbase is defining "who holds the account" (wallet layer).

What Circle and Tether are doing is something else entirely: what money the machines use to pay. The role of stablecoins here is actually closer to "base money" than a "payment instrument".

Machine payments only have a realistic basis when funds themselves can be accessed via APIs, embedded in programs, and flow across systems at low cost. In other words, agentic payments are largely based on the premise that "money has been digitized and is programmable."

However, there's an easily overlooked boundary: making money programmable doesn't mean machines can safely spend it. True agentic payment still requires:

Authorization System
Authentication
Risk control mechanism
Attribution of responsibility

These capabilities are precisely the layers that Stripe, Visa, and Google have been filling in. Therefore, from a more holistic perspective, Agentic Payment isn't a capability that any single player can accomplish alone; rather, it's more like a system being pieced together: the protocol is evolving, identities are evolving, wallets are evolving, and the currency is, in fact, already prepared.

The real uncertainty lies not in whether there is money, but in when the system will be truly put together and begin to support real transactions.

PayPal / OpenAI: Closer to the transaction entry point and front-end interaction layer

PayPal's explanation of "agency commerce" leans more towards the actual transaction experience in the world of consumers and merchants, emphasizing how AI helps users complete purchases and how different levels of authorization models unfold in checkout scenarios. OpenAI, on the other hand, is closer to the front-end entry point: turning chat interfaces like ChatGPT into transaction traffic entry points, and then connecting them with the merchant/checkout system.

However, a noteworthy signal has recently emerged at this level: Google continued to strengthen its open commerce protocol in early 2026, instead of locking all purchases into a closed loop on a single platform. This itself indicates that even the platforms closest to the traffic entry point are still exploring whether to act as a "direct transaction entry point" or an "open transaction orchestration entry point." This precisely illustrates a problem: the final consensus has been reached, but the implementation path is still undetermined.

Third, everyone is making grand promises, but in the end, whoever delivers the results first wins.

Looking at the paths and players together, it becomes clear that the competition in Agentic Payment today, on the surface, seems to be about who releases the protocol first, who launches the wallet first, and who explains the end result first; but what truly determines the winner is not necessarily who tells the complete story first, but who verifies the real transaction demand first.

Because the payment industry is not one that can be established simply through demonstrations. A protocol can be launched, a standard can be released, and a wallet can be created very quickly.

With the launch of the Tempo mainnet, MPP has clearly identified machine-to-machine payments as its direction; Google has combined AP2 and UCP into an open standard for agency commerce; and Coinbase is pushing Agentic Wallets and x402 towards "AI agent-native payment capabilities." In other words, what's lacking today isn't just the "concept," but whether there's a sufficiently high-frequency, standardized, and low-friction real-world payment demand behind these infrastructures.

This is why, although the end result is becoming clearer, the execution path is still not finalized; not all imagined payment scenarios will become real transactions.

Some scenarios are perfect for demos, but not necessarily for market development. Some scenarios sound exciting, but once they enter the real business world, they will encounter issues such as licensing, dispute resolution, contract fulfillment, compliance, and cost structure.

Ultimately, what the payment industry needs to see is not "whether this can be demonstrated," but "whether this can happen consistently many times."

Therefore, what's truly worth watching next isn't which company releases a new protocol or which platform proclaims a more comprehensive vision for academia commerce; rather, it's whether any type of transaction is starting to occur consistently through this new infrastructure. Are there orders? Are there payments? Are there repeat purchases? Are there continuously increasing call and settlement frequencies? These questions are more important than any single slide in a presentation.

From this perspective, the company that will emerge victorious in the future may not necessarily be the one that tells the most complete story, but more likely the one that first finds the anchor point of real needs.

Whoever finds high-frequency, standardized, low-controversy, and automatable scenarios first is more likely to truly develop a particular layer. Conversely, if there's only a protocol without continuous transactions, only a wallet without stable payments, only an endgame narrative without real orders, then even the most complete infrastructure stack is likely to remain in a stage of "concept first, demand lagging behind." Coindesk's March report on x402 actually pointed out this reality quite bluntly: technology is advancing, but real demand and large-scale adoption have not yet fully caught up.

This is why I believe the most worthwhile aspect of the industry going forward isn't who can explain Agentic Payments clearly first, but rather who can popularize a specific type of real-world transaction. Once orders and payments in a particular scenario begin to occur stably, the protocols, identities, authorizations, wallets, and clearing processes mentioned earlier will truly move from the "conceptual layer" to the "infrastructure layer." Ultimately, the Agentic Payments race isn't about who can better envision the end result, but about who can first transform a real-world need into a continuous flow of payment behavior.

Fourth, the first thing to emerge won't be the sexiest scene.

If Agentic Payment were to actually happen, in which scenarios would it first occur? Many people's first reaction would be to imagine a very "big" scenario: AI completing an international trip for you, from booking flights and hotels to rescheduling and compensation, with all payments done automatically; or AI directly completing cross-border procurement and supplier settlements for businesses, and even automatically managing budget pools.

These assumptions are certainly valid, and Visa's current agent travel narrative is precisely about this kind of high-value scenario: agents can package air tickets, hotels, and offers for cardholders, and if the itinerary changes, they can automatically rebook and complete secure payments.

However, the scenarios that will likely emerge first are not the ones with the "best storytelling potential." The reason is simple: the payment industry doesn't reward the most appealing scenarios first, but rather those that are easiest to create a closed loop.

For a scenario to run successfully, it typically needs to meet at least four conditions simultaneously:

Transactions are sufficiently standardized
Performance is timely enough
Low enough controversy rate
The authorization boundaries are clear enough

By this standard, the first thing to be verified is likely not "AI completing the entire trip for me," but rather the following types of data-intensive scenarios that may not seem so glamorous, but are more likely to generate real transactions.

1. API payment, computing power access, and data access: This is the first step that most closely resembles native machine payment.

If there is a most natural starting point for Agentic Payment, it is most likely digital services such as APIs, tools, data, and computing power.

Because these types of transactions are almost naturally suited to be done by machines: delivery is instant, billing is transparent, fulfillment is standardized, and in most cases there are no complicated refund and after-sales issues.

The machine doesn't need to handle color, size, subjective preferences, and reverse logistics like it does when buying a sofa or a piece of clothing; it only needs to determine: whether this interface is worth calling, whether this service should be purchased again, and how much this call will cost.

This is why, when Coinbase launched x402, its primary emphasis wasn't on "AI buying things for you," but rather on enabling APIs, applications, and AI agents to directly complete stablecoin payments via HTTP. Coinbase's publicly stated typical approach is direct transactions between APIs, apps, and AI agents. The key to this type of scenario isn't "coolness," but rather its inherently high frequency.

A model call, a data retrieval, or an automated task execution are all triggered by a program. Only when payments can be completed natively by a program can the entire transaction chain truly be closed. Therefore, in my own judgment, the earliest manifestation of Agentic Payment will not be "AI helping people shop," but rather "machines paying for machines."

2. Digital goods and subscriptions: The second wave is most likely to see them gain traction first.

The second category, which is easiest to scale up initially, includes digital goods, software subscriptions, content services, and cross-border SaaS renewals.

The reasons are similar to the previous one: fast delivery, fewer disputes, automatic renewal logic already exists, and the amount is usually easier for users or businesses to pre-authorize than physical consumption.

PayPal's recent merchant-facing content on academia commerce is also moving in this direction: while creating a merchant readiness checklist, it is emphasizing the cross-border expansion value of digital goods and subscription businesses, directly listing software, content, and subscriptions as key types suitable for cross-border delivery and recurring payments.

Why are these scenarios important? Because they naturally shift Agentic Payment from "one-time payment" to "recurring payment".

Once it enters the stage of continuous payments, the layers mentioned earlier—authorization, identity, risk control, and account—will truly be brought into play. In other words, what truly propels Agentic Payments to the third and fourth stages is not necessarily a one-off, high-tech transaction, but rather a large number of ordinary, repetitive, and standardized subscription payments.

3. Standardized expenses within a company: These tend to be accepted for agentic payment earlier than personal consumption.

When discussing Agentic Payments, many people assume they're referring to consumer-facing (C-end) shopping. However, in reality, business-to-business (B-end) scenarios are likely to embrace it sooner. The reason is simple: businesses are already accustomed to budgeting, approvals, supplier whitelists, and risk control rules.

For businesses, "making machines spend money" is not something that is unacceptable in principle. The key is whether the boundaries are clearly defined, whether the process can be audited, and whether the responsibility can be traced back.

In its public statements regarding AP2, Google has placed "autonomous financial workflows" at the forefront, and participants like Intuit have also explicitly mentioned that the protocol can be used to deploy more automated financial workflows.

This means that what the enterprise world will first validate isn't necessarily "agents making money on their own," but rather some very simple things: automatically renewing SaaS subscriptions, automatically replenishing cloud resource limits, automatically paying small bills from fixed vendors, or completing standardized purchases within a clear budget pool. These things aren't as glamorous, but they are very real.

Moreover, once it's running smoothly, its reusability is very high. So if you ask me which scenario is most likely to make the authorization system truly mature first, I would say it's not the shopping cart, but the standardized expenditure management within an enterprise.

4. Travel and high-value consumption will attract attention, but they won't be the first sectors to achieve widespread adoption.

These kinds of scenarios will definitely be showcased extensively because they are the most visually appealing and best suited for product launch demos. One of Visa's current key focuses is travel: its agent helps users combine flights, hotels, and offers, and can automatically reschedule and complete payments when travel plans change.

Google is also pushing for agenda shopping for retailers and merchants, emphasizing how open standards and merchant data can make it easier for high-intent users to complete transactions with retailers through entry points like Search. However, making these scenarios viable on a large scale is actually much more difficult than for digital services. This is because they involve:

More complex fulfillment chains
Higher average order value
Stronger subjective preferences
Higher probability of after-sales disputes
Heavier responsibilities and risk control pressure

This is why Visa itself repeatedly emphasizes the trust issue in its research: In its 2025 consumer study in the US, Australia, and New Zealand, approximately 85% of respondents wanted clear control over the data their agents could access, about 43% worried about agents making mistakes, and about 50% were concerned about "making decisions for them without their involvement." This data actually illustrates a reality: high-value, high-controversy, and highly subjective scenarios, while most easily used to discuss the future, are precisely not the first to become the starting point for large-scale validation of Agentic Payments.

5. The real dividing line is not how big the scene looks, but whether it can consistently generate orders.

Ultimately, for Agentic Payment to move from narrative to reality, it's not about a single, impressive demo, but about the continuous occurrence of a specific type of transaction. The key factors are: are there orders, are there consecutive payments, are there repeat purchases, and is there an increasing frequency of calls? That's the dividing line.

Therefore, my own judgment is that Agentic Payment will first emerge in scenarios with low friction, pre-authorization, instant delivery, low dispute, and inherently suitable for programmatic invocation. More specifically, the priority will likely be:

The first wave includes APIs, data, computing power, and digital services.
The second wave includes subscriptions/SaaS/cross-border digital goods.
The third wave involves standardized expenditures within enterprises.
Later on, we'll see travel, e-commerce shopping, and more complex consumer scenarios.

This also means that what's truly worth watching next isn't which platform is telling another bigger shopping story, but rather: what kind of real transactions are starting to run continuously on these protocols, wallets, and stablecoin networks.

Once these types of transactions begin to occur steadily, the protocols, identities, authorizations, wallets, and currencies mentioned earlier will truly transform from "conceptual puzzle pieces" into "infrastructure."

V. The real barrier to Agentic Payment is not the payment itself, but the authorization system.

Why, despite the emergence of protocols, wallets, stablecoins, and trust layers, hasn't Agentic Payment taken off across the board? The answer is simple. The real challenge isn't "how to pay out the money," but rather: who has the authority to make that money go through?

The payment industry appears to be processing transactions, but at its core, it's constantly handling authorization. Why can a card be swiped? Because the cardholder has authorized it. Why can corporate purchases be made? Because there are approval and budgeting authority behind it. Why can automatic renewals be made? Because the user has given prior, revocable authorization.

Therefore, what Agentic Payment truly aims to solve is not teaching AI to call payment interfaces, but rather getting the financial system to accept a new problem:

When the transaction initiator becomes a machine, how should authorization be defined, verified, restricted, and revoked?

This is why many of the most critical moves in the industry now are not simply optimizing "payment capabilities," but rather improving the authorization layer.

Visa's Trusted Agent Protocol essentially addresses the question of "who can act on behalf of whom." Visa officially defines it as a foundational framework that enables secure communication between AI agents and merchants throughout the transaction process, aiming to establish trusted relationships in agent-driven commerce. Visa Intelligent Commerce in the Asia Pacific region also emphasizes that the core value of the Trusted Agent Protocol is enabling merchants to identify and verify "trusted agents with genuine business intent."

Google's AP2 is not simply a tool that "connects payments to agents." In its official documentation, Google defines AP2 as an open protocol that allows AI agents to securely initiate and execute payments on behalf of users, and explicitly emphasizes that it must work in conjunction with agent protocols such as A2A and MCP. In other words, it doesn't handle the individual payment itself, but rather how agents complete payment actions in an auditable and verifiable manner across cross-system environments.

PayPal's recent explanation to consumers regarding Agentic Commerce actually puts the authorization issue quite clearly: users can choose to let AI complete the purchase on their behalf, or they can request "reconfirmation before purchase." This statement seems simple, but it actually reveals the hierarchical authorization structure of Agentic Payments—in the future, not all payments will use the same authorization model, but rather both "successive confirmation" and "pre-authorization" logic will coexist.

Stripe's MPP is similar. In its official blog, Stripe defines MPP as an open standard that allows agents and services to coordinate payments programmatically, supporting scenarios such as micropayments and revolving payments. This definition sounds like it's talking about a payment protocol, but what it's really promoting is something else entirely: transforming "payment" from a single human action into a systemic behavior that can be triggered by programs but must be constrained by rules.

Therefore, if we break down Agentic Payments further, you'll find that its real barrier isn't the payment rail, but the authorization rail. In other words, the truly valuable technology in the future may not be an "AI payment button," but rather the following capabilities:

First, the boundaries of authorization must be productizable.

Users or businesses can't simply say, "Let AI buy for me." The system must clearly define the authorization rules: spending limits, merchant whitelists, category restrictions, time windows, budget pools, whether automatic renewal is possible, and whether secondary confirmation is required. These aren't just user experience details; they are prerequisites for truly empowering payment systems.

Second, the authorization status must be dynamically verifiable.

Today's payment authorizations are mostly one-off, but agent transactions are often continuous, cross-step, and even conditional. This means that future systems will not only need to know "whether authorization has been granted," but also "whether the current step is still within the authorization boundaries."

Third, authorization must be revocable and traceable.

This is the biggest difference between Agentic Payment and regular automation. Because machines may execute multiple actions consecutively when you're not monitoring them, users and businesses must be able to pause, revoke, and modify permissions at any time. Otherwise, authorization becomes a source of risk, not an efficiency tool.

Fourth, the authorization result must be understandable to both the merchant and the payment network.

This is why players like Visa, Google, and Stripe are all developing their own protocol layers. It's meaningless for users to set their own rules; what's truly important is that merchants, wallets, payment networks, and clearing networks all need to be able to understand this authorization and decide whether to accept the transaction accordingly.

From this perspective, Agentic Payment is not simply automating "human payment," but rather reprogramming the process of "payment authorization."

That's why I think the most worthwhile thing to watch next isn't which company releases a new payment protocol, but which company makes its authorization system a truly usable product first.

Because the agreement addresses "how to pay".
A wallet solves the problem of "who holds the account".
Stablecoins solve the problem of "what money to use to pay".

But what truly determines whether Agentic Payment can succeed is whether the system dares to allow the machine to transfer money on your behalf without your confirmation. And this issue, ultimately, isn't about payment; it's about authorization.

VI. As we all saw in the end, what truly determined the outcome was who paved the way first.

The endgame of Agentic Payments is no longer a novelty. From the launch of the Tempo mainnet and the introduction of MPP, to Visa's Trusted Agent Protocol and Intelligent Commerce, and then to Google's AP2/UCP and Coinbase's Agentic Wallets, the industry is increasingly speculating about what the future will look like: the initiator of payments will gradually shift from "manual confirmation by humans" to "machine execution within authorized boundaries"; and the protocol layer, trust layer, wallet layer, and currency layer surrounding this are already emerging.

But the clearer the ending becomes, the more it illustrates one thing: what truly sets us apart is not who can present a more complete picture of the future, but who can first pave the way through the middle path.

Because payments are not an industry that can be rewritten simply by imagination. Ultimately, it's not about demos, press conferences, or which word is updated, but about whether there are real transactions, consistent payments, acceptance by users and merchants, and stable execution without confirmation by the system. Coindesk's March report on x402 already highlighted this reality: technology is advancing, but real demand and large-scale adoption haven't fully caught up.

Therefore, what's most worth watching next isn't who releases another new protocol, nor who proclaims a grander vision for academia commerce. What's truly worth watching are three more concrete things:

First, which type of real transactions will occur first and then stabilize?
Second, which authorization system will be accepted by users and merchants first?
Third, which layer of infrastructure will first transform from a "conceptual puzzle" into a "default component"?

This is why I believe that in the short term, the most important thing about Agentic Payments is not whether the "end result is correct," but whether the "path is viable." The end result is certainly important, but it's more like a direction.

What truly determines industry differentiation are always the details within the path:

Whoever turns the license into a product first,
Whoever establishes trust as a standard first,
Whoever turns the wallet into an account first,
Whoever makes stablecoins truly usable by machines first,
Whoever first turns a certain type of transaction into a continuous payment activity.

Ultimately, Agentic Payment is not a single innovative concept.

It's more like a recombination: turning money back into a callable infrastructure, payments back into programmable system behavior, and authorization back into rules that machines can understand. The real watershed moment isn't about whether AI will pay, but rather when the financial system will acknowledge that machines can spend money on behalf of people within certain boundaries. So, we've all seen the end result. What truly determines victory or defeat is who paves the way first.

The Astra Nova team is suspected of accumulating $1 million worth of RVV tokens through a new wallet.

Popular Articles