MoonPay launches open wallet standard to unify AI agent payments across blockchains

Amid accelerating growth in AI-driven payments, MoonPay has introduced the open wallet standard to give autonomous systems a secure, interoperable way to transact across blockchains.

MoonPay unveils a universal wallet layer for AI agents

On March 23, 2026, MoonPay announced the launch of the Open Wallet Standard, an open-source specification that lets AI agents hold value, sign transactions, and pay for services on every major blockchain without exposing a private key. The framework is already live on GitHub, npm, and PyPI, with contributions from more than 15 organizations.

Backers span key layers of the crypto and fintech stack, including PayPal, OKX, Ripple, Tron, TON Foundation, Solana Foundation, Ethereum Foundation, Base, Polygon, Sui, Filecoin Foundation, LayerZero, Dflow, Uniblock, Virtuals, Arbitrum, Dynamic, Allium, Simmer.Markets, and Circle. Together, they are helping define how agents interface with value on-chain.

“The agent economy has payment rails. It did not have a wallet standard. We built one, open-sourced it, and now the full stack exists,” said Ivan Soto-Wright, CEO and co-founder of MoonPay. His comment underlines the company’s intent to position this standard as a missing piece of the emerging agent economy.

From MoonPay Agents to a shared industry standard

The new specification evolved from MoonPay’s internal product roadmap. In February 2026, the company launched MoonPay Agents, a non-custodial software layer that lets AI agents access wallets and funds, and transact autonomously via the MoonPay CLI. The product shipped with x402 compatibility and multi-chain support, targeting developers building automated financial workflows.

Earlier in the same month, MoonPay integrated Ledger hardware signing into the agent stack, making it the first agent-focused wallet to support hardware-backed transaction approvals. That addition ensured that hardware signing ledger functionality could secure agent transactions at the same level as human-operated wallets.

However, as MoonPay built out this infrastructure, it ran into a systemic issue facing every agent framework: there was no common standard for how AI agents interact with wallets. Each framework implemented its own key management and signing logic, leaving wallets siloed and incompatible. Private keys often ended up in environment variables, plaintext configuration files, or proprietary formats, with no portability or unified security model.

MoonPay responded by abstracting the wallet layer behind MoonPay Agents, generalizing it across chains and runtimes, and releasing it under an MIT open-source license. That generalized wallet architecture is now formalized as the Open Wallet Standard.

The standard debuts with contributions from the same broad coalition of organizations across the industry stack, from payments and exchanges to foundations and infrastructure providers. Moreover, this collaborative approach is intended to drive early interoperability rather than lock-in.

The missing layer in the agent payments stack

Over the last year, the agentic payments landscape has evolved quickly. Coinbase and Cloudflare launched x402 for HTTP-native stablecoin payments. Google introduced the Agent Payments Protocol (AP2) with more than 60 partners to enable agent-driven commerce. Stripe and Tempo rolled out the Machine Payments Protocol (MPP) for session-based micropayments. Meanwhile, the Ethereum Foundation published ERC-8004, creating on-chain identity registries for trustless agents.

These protocols emerged independently, but together they form much of the technical stack for the agent economy. However, they share a key assumption: that the agent already has a wallet. None specifies how or where the wallet is implemented, how keys are stored, or how a wallet created for one agent can be safely reused by another.

In practice, this leads to fragmentation. A user who runs three different tools or autonomous agents typically ends up with funds scattered across three separate wallets that cannot see each other. The same $100 in stablecoins effectively becomes $33 in three places, with no straightforward way to present one consolidated balance across all tools.

The Open Wallet Standard is designed to close this gap by offering one encrypted vault on the user’s machine, one interface for every chain, and a security model in which the private key is never exposed to the agent, the LLM, or any parent process. When x402 returns a payment request, the standard’s implementation produces the signed authorization. When MPP opens a session and streams micropayments, the wallet signs each payment within the agent’s configured limits.

That said, the protocols such as x402 and the Machine Payments Protocol made machine payments technically possible; MoonPay argues that its specification makes them usable at scale. With this wallet layer in place, the company claims the full stack for the agent economy is effectively assembled.

How the standard interacts with existing protocols and tools

MoonPay emphasizes that this framework does not compete with existing payments and identity protocols. Instead, it is meant to increase their value. Any protocol that requires a signed transaction can now call a shared wallet interface. Any tool or agent implementing the standard can access the same vault and funds, similar to how multiple mobile apps can connect to a single bank account.

In a typical flow, an AI agent maintains a balance within an encrypted vault compliant with the specification. It receives a payment request via x402 for compute credits, an API call, or a dataset. The policy engine evaluates the request against the agent’s spending limits. Next, the wallet decrypts the key in an isolated process, signs the transaction, clears the key from memory, and returns the signature. The agent pays and the service delivers, while the private key never touches the agent or LLM context.

The same vault can open an MPP session, stream micropayments to another service, and settle without altering the underlying wallet logic. Moreover, this uniform behavior allows developers to build ai agent wallets that operate consistently across diverse frameworks and application domains.

Industry contributors view the effort as foundational infrastructure. “On-chain payments originate from wallet addresses, and every chain represents them a bit differently. A unified representation makes it easier for an agent to focus on the high-level task instead of details,” said Sam Blackshear, co-founder and CTO of Mysten Labs. He added that Mysten Labs is investing heavily in agent infrastructure on Sui and is pleased to support the standard.

“Nobody building a serious agent is going to limit it to one chain. The Open Wallet Standard treats every network as a first-class citizen, and that is why TON is contributing to it,” said Max Crown, President and CEO of TON Foundation. His remarks highlight the importance of native multi chain support for the next generation of autonomous services.

Open source design and modular specifications

The specification is MIT-licensed and intentionally modular. It is composed of seven sub-specifications that define storage, signing, policies, agent access, key isolation, wallet lifecycle, and supported chains. Each module can be adopted independently, allowing teams to integrate only the components they need while maintaining interoperability.

There are no proprietary formats or closed dependencies. Implementations can import from MetaMask and export to any wallet. Moreover, this approach aims to prevent vendor lock-in and to encourage a broad ecosystem of compatible tools and services around the specification.

The standard also introduces an open skills marketplace where developers can publish wallet-compatible capabilities, including signing plugins, compliance modules, and chain adapters. There is explicitly no gatekeeping, so any organization can contribute modules and extend functionality. Over time, this marketplace could help agents access specialized features without custom wallet code.

For MoonPay, the Open Wallet Standard marks the latest step in a deliberate move toward AI-native infrastructure. Over the past year, the company has progressed from on-ramp APIs to the MoonPay CLI, to MoonPay Agents with Ledger-secured hardware signing. Each iteration has granted AI agents more direct, programmable access to financial rails. Now, the standard opens that infrastructure to every agent, every framework, and every chain.

How the Open Wallet Standard works in practice

At the technical level, the design centers on zero key exposure. AI agents operate inside LLM contexts where data can appear in prompts, logs, or tool calls. The specification therefore mandates that private keys remain inaccessible to the agent process. Keys are encrypted at rest with AES-256-GCM, decrypted only to generate a signature, held in protected memory that cannot be swapped to disk, and wiped immediately afterward.

The framework also provides a unified signing interface for many networks. A single seed phrase can derive accounts across eight chain families: EVM, Solana, Bitcoin, Cosmos, Tron, TON, Spark, Filecoin, and the XRP Ledger. One signing API uses CAIP-2 chain identifiers, ensuring that a wallet created for one agent works with every supported protocol, framework, and chain.

Spending is controlled through policy gated signing. Autonomous agents should not have unlimited authority over funds, so a pre-signing policy engine evaluates every transaction before any key operation occurs. The wallet can enforce spending limits, contract allowlists, chain restrictions, and time-bound authorizations directly at the wallet layer. The operator defines the rules, and the agent must operate inside those constraints.

Moreover, the architecture is designed for agent-native access. It includes SDK bindings for Node.js and Python, a dedicated CLI, and an MCP server interface. Agents built on Claude, ChatGPT, LangChain, or any MCP-compatible framework can connect to wallets through their native tool systems, minimizing integration friction for developers.

The standard also prioritizes a local first wallet model. The encrypted vault resides on the user’s machine, with no cloud accounts or remote key management required and no network dependency for signing operations. The only network call the wallet needs to make is to broadcast a signed transaction to the target blockchain.

Availability and integration paths for developers

Developers can install a reference implementation via a simple script: curl -fsSL https://openwallet.sh/install.sh | bash. The Node.js SDK is available through npm using npm install @open-wallet-standard/core, while the Python SDK can be installed with pip install open-wallet-standard. The full specification and source code are hosted at github.com/open-wallet-standard, and documentation is available at openwallet.sh.

That said, as more developers adopt the Open Wallet Standard in their own stacks, compatibility across protocols like x402 stablecoin payments and the Machine Payments Protocol is likely to improve. Shared wallets should help reduce fragmentation and provide a more coherent user experience across multiple agents and services.

About MoonPay

Founded in 2019, MoonPay is a global financial technology company focused on bridging fiat and digital assets. The firm serves more than 30 million customers across 180 countries and supports over 500 enterprise customers, ranging from crypto platforms to fintech providers.

Through a single integration, MoonPay powers on- and off-ramps, trading, crypto payments, and stablecoin infrastructure, linking traditional payment rails with public blockchains. Moreover, the company positions itself as core infrastructure for the broader digital asset ecosystem.

MoonPay describes its mission simply: to be the way the world moves value. For media enquiries, the company can be reached at [email protected].

By releasing a universal wallet layer as open source, MoonPay is betting that shared standards for key management, signing, and agent access will accelerate the agent economy and make autonomous, on-chain payments both safer and easier to build.