Who Is Watching the Agents?
Sometime in the next few years, you will tell an AI agent to book you a flight, negotiate a vendor contract, or rebalance your portfolio. The agent will do it. It will also do the next forty things on its list while you eat lunch. By the time you check back, it will have made hundreds of decisions with your money, your identity, and your authority.
You will not have supervised any of them.
This is the reality that the agentic economy is building toward, and it introduces a problem that existing institutions handle poorly even among humans: how do you ensure that someone acting on your behalf actually serves your interests? Economists call this the principal-agent problem. When both parties are human, we manage it with contracts, incentives, reputation, and the occasional performance review. When the agent is software operating at machine speed, none of those tools work. The agent acts too fast for real-time oversight. The feedback loop between action and accountability stretches to the point of meaninglessness.
So trust has to live somewhere else. It has to be structural.
The infrastructure thesis
The instinct in tech is to solve trust at the application layer: build a better agent framework, add guardrails to the model, train it to be aligned. These are necessary steps, and none of them are sufficient. Agent frameworks get replaced every eighteen months. Models get retrained. Guardrails are only as durable as the team maintaining them.
The layer that persists is the settlement layer, where transactions are recorded, where authorizations can be verified by anyone, and where the question "was this agent permitted to do that?" has a definitive, cryptographic answer. If trust is going to scale with agent speed, it has to be encoded at the infrastructure level, into the ledger itself.
This is what we have been building at MultiversX.
The Universal Agentic Commerce Stack
Over the past year, six independent protocol coalitions, none of them coordinated by us, have published open standards for how AI agents should discover, negotiate, authorize, and settle economic activity. We have integrated all six into a single settlement layer. Here is what each one does.
MCP, Anthropic's Model Context Protocol, lets AI assistants query external systems. Our MCP server exposes fourteen blockchain tools, so any compatible agent can read onchain state and initiate transactions without custom integration.
UCP, the Universal Commerce Protocol backed by Google, Shopify, Walmart, and Target, handles the full commerce lifecycle: product discovery, cart management, checkout, and post-purchase support. MultiversX was the first Layer 1 to ship a UCP integration.
ACP, OpenAI and Stripe's Agent Commerce Protocol, standardizes how agents execute purchases in automated environments. We maintain an open-source adapter.
MPP, Stripe's Machine Payments Protocol, provides infrastructure for agent-to-agent payments, letting software pay software without human intermediation at every step.
x402 turns the HTTP 402 status code into a real payment mechanism. An agent that needs access to a paid API simply pays per request, in real time, with no subscription, no API key management, no billing cycle. Coinbase and Cloudflare are among the backers.
And then there is AP2.
The authorization layer
AP2, the Agent Payments Protocol developed by Google with American Express, Mastercard, PayPal, Coinbase, Salesforce, and over sixty other organizations, solves the problem that none of the other five protocols address directly: proof of authorization.
When an agent makes a purchase, three questions need definitive answers. Was the agent authorized to act? Does the transaction reflect what the user actually intended? And if something goes wrong, who is accountable?
AP2 answers these through Verifiable Digital Credentials, cryptographically signed data structures that create an unbroken chain from user intent through agent execution through final settlement. Three credential types cover the full lifecycle:
The Intent Mandate captures the boundaries the user set. "Buy concert tickets when they go on sale, under $200." The agent proves it operated within those constraints. The Cart Mandate records explicit approval for a specific transaction, binding the user's signature to exact items, prices, and merchant details. The Payment Mandate signals to payment networks that an agent was involved, including whether a human was present at the time of the transaction, so risk systems can assess accordingly.
Each mandate links cryptographically to the next. An Intent Mandate references the Cart Mandate it produced. The Cart Mandate references its Payment Mandate. The result is a verifiable chain of custody for authorization, recorded onchain, auditable by anyone.
This is what it means to turn agent alignment from a social contract into an engineering specification. "Was this agent authorized?" becomes a question with a cryptographic answer.
There is one more piece. AP2 proves authorization. But the ledger also needs to know which agent acted. MX-8004, MultiversX's onchain identity standard for AI agents, establishes agent-specific identity at the account layer. When a transaction settles, the record shows that a specific agent, operating under a specific authorization, executed a specific action. Attribution is structural, embedded in the ledger rather than reconstructed from logs after the fact.
Why speed matters
There is a timing problem that makes all of this fragile if the settlement layer is slow.
An AI agent operating in a competitive environment, bidding on inventory, executing arbitrage, responding to price changes, acts on the order of hundreds of milliseconds. If the infrastructure that records and verifies its authorizations takes six seconds, or twelve, or sixty, then the trust architecture is always running behind the agent it is supposed to govern. The verification happens after the fact. Disputes multiply. The audit trail becomes forensic rather than preventive.
Sub-second finality closes that gap. When Supernova activates, MultiversX block times drop from six seconds to 600 milliseconds. Intra-shard finality has been measured at 88ms in testing. Cross-shard settlement completes in under two seconds. The mechanism is structural: consensus and execution are decoupled, so validators agree on transaction ordering first and execution follows in parallel.
At these speeds, the settlement layer operates inside the agent's decision cycle. The trust infrastructure keeps pace with the thing it is meant to govern.
The toll on every transaction
Every agent transaction, every micropayment, every authorization check, every credential verification, settles through an infrastructure layer. The protocols define the rules. The settlement layer records the outcomes. Whoever operates the layer where agent trust is verified and recorded captures the toll on every transaction in the agentic economy.
There is a final question worth taking seriously: what happens when agentic commerce scales to the volume of internet commerce itself? A settlement layer that works at today's demand may not survive tomorrow's. MultiversX was designed from its first line of code as a sharded architecture, splitting network, transaction, and state processing across parallel execution shards that can scale with demand. This is a foundational design choice. Sharding cannot be retrofitted onto a monolithic chain any more than load-bearing walls can be added to a finished building. If agent-driven commerce reaches the throughput of global internet transactions, many of today's single-lane highways will simply crumble under the weight.
We are building the infrastructure for agents to transact at scale: secure, verifiable, and lightning-fast.
This is what Supernova is for.
