The MultiversX Universal Agentic Commerce Stack

MultiversX Unveils Flagship Multi-Protocol Universal Agentic Commerce Stack

AI agents have now moved from demos to full production economic actors. They schedule travel, reconcile invoices, manage inventory, trigger payments, and coordinate workflows with minimal human involvement. This shift has moved quickly from experimentation to production deployment.

The underlying infrastructure has lagged behind. Most blockchain systems were designed around interactive users, manual approvals, and sporadic transactions. Agent-driven systems operate continuously, programmatically, and across multiple environments. They require different assumptions at the protocol level.

Over the past two weeks, we implemented a set of protocol integrations designed specifically for this mode of operation. Together, they form a complete stack for agentic commerce: discovery, authorization, execution, settlement, and performance.

Infrastructure Requirements for Agent Commerce

Agent commerce introduces a different set of constraints than user-facing applications.

Agents require programmatic access to execution and payment rails. They operate under delegated authority that must be provable and auditable. Their workflows span multiple steps and multiple systems. Transaction volumes are high, values are often small, and latency compounds across dependent actions.

Meeting these requirements requires coordination across standards, protocols, and base-layer capabilities. No single component is sufficient on its own.

The Universal Agentic Commerce Stack

MultiversX has shipped five protocol integrations that align with these requirements:

• Universal Commerce Protocol (UCP): standardized discovery and interaction across the commerce lifecycle  
• Agent Commerce Protocol (ACP): programmatic checkout and transaction execution  
• Agent Payments Protocol (AP2): cryptographic authorization and delegated intent  
• Model Context Protocol (MCP): structured access to onchain state and execution  
• x402: HTTP-native payment settlement for machine-to-machine transactions  

Each protocol addresses a specific layer of the agent commerce lifecycle.

Structured Discovery and Interaction

Universal Commerce Protocol defines how agents discover and interact with services across the full commerce lifecycle, including discovery, checkout, order management, and post-purchase flows. It is an open standard developed by Google in collaboration with major commerce platforms.

MultiversX is the first Layer 1 blockchain to integrate UCP.

The integration is implemented through Model Context Protocol, maintained by the Linux’s Agentic AI Foundation. MCP defines how AI systems connect to external tools. On MultiversX, blockchain operations are exposed as structured, typed functions with explicit parameters and validation.

Agents interact with onchain state and execution through defined interfaces. This approach removes ambiguity and allows different models to operate against the same infrastructure without custom training or bespoke integrations.

Programmatic Checkout and Execution

Agent Commerce Protocol standardizes the execution of purchases within conversational and automated environments. It defines how agents construct transactions and complete payments programmatically.

MultiversX supports ACP with native integration into the protocol layer. Execution is handled through Relayed v3, enabling transactions where fees are covered by relayers instead of end users. This execution model supports high-frequency, low-value transactions that would otherwise be economically impractical.

The result is a payment flow that aligns with agent behavior: continuous operation, predictable costs, and minimal friction.

Authorization and Accountability

Agent Payments Protocol provides a framework for expressing and verifying delegated authority. It was developed by Google in collaboration with payment networks and financial institutions to support agent-mediated transactions.

AP2 introduces verifiable digital credentials that encode authorization as cryptographic mandates. These mandates capture operating conditions, transaction approval, and agent involvement in a form that can be validated independently.

The protocol supports three mandate types: intent mandates that define operating constraints, cart mandates that capture approval for specific transactions, and payment mandates that signal agent involvement to downstream systems. Together, they create an auditable chain from delegated authority to settlement.

Settlement and Interoperability

x402 provides HTTP-native settlement primitives that allow agents to exchange payment instructions in machine-readable form. This enables agents to process invoices, requests, and responses without custom parsing or out-of-band coordination.

Combined with ACP and AP2, x402 supports end-to-end commerce flows that span multiple platforms and execution environments.

Performance Characteristics

Agent workflows involve sequences of dependent actions. Latency accumulates across each step. Network performance directly affects usability at the system level.

MultiversX’s architecture supports this workload through adaptive state sharding and fast finality. The upcoming Supernova upgrade brings 600ms block times with sub-300ms finality. In practice, complete agent workflows settle within a timeframe that supports interactive operation.

Relayed execution and horizontal scaling ensure that increased agent activity does not degrade performance characteristics.

What This Enables

With these components in place, agents can:

• Discover services through standardized interfaces
• Execute payments programmatically without holding native gas tokens
• Operate under explicit, verifiable authorization constraints
• Settle transactions across platforms using shared protocols

Developers can build systems where autonomous components coordinate economically without manual intervention. Users can delegate bounded authority with clear auditability. Businesses can deploy agent-driven workflows that remain predictable under load and dispute.

Let A Thousand (A Million? A Billion?) Agents Bloom 

These integrations are live and available today. They reflect a coordinated approach to agent commerce infrastructure rather than isolated feature development.

As agent-driven systems take on more economic activity, the requirements become clear: reliable execution, explicit authorization, predictable performance under load. Those requirements are already shaping the standards the agent ecosystem is converging on.

MultiversX has implemented those standards at the base layer. The network now supports agent discovery, delegated authorization, programmatic execution, and settlement as a single, coherent system.

This is infrastructure built for the way commerce is starting to operate.

‍

Read the technical details and start building:

UCP + MCP integration: https://github.com/sasurobert/multiversx-mcp-server

ACP integration: https://github.com/sasurobert/multiversx-acp-adapter

AP2 integration: https://github.com/sasurobert/AP2

X402 integration: https://github.com/sasurobert/x402