6 min read

Introducing OWS, the Open Wallet Standard

Source: http://x.com/i/article/2036075462015799296

Today we're open-sourcing the Open Wallet Standard (OWS), a secure, local-first protocol that gives AI agents and developer tools a single way to store keys, manage wallets, and sign transactions across every major blockchain.

One vault, one interface, every chain.

The agentic payments stack has arrived. For the first time -- via x402, MPP, and A2A — AI agents can pay for things — APIs, compute, data — without a human in the loop.

But there's a gap in the stack that nobody's addressed.

Every one of these protocols assumes your agent already has a wallet.

x402 needs a signed EIP-3009 authorization. MPP needs a signed payment from a funded account. They define how agents pay. None of them define where the private key lives, how it's stored, how it's protected, or how two different tools share access to the same wallet.

The actual problem

Let's be specific. You're building an agent. It needs to sign transactions.

Here's what that looks like today:

Your private key is a hex string in a .env file, or an environment variable, or a plaintext field in a JSON config. Your agent process reads it at startup, holds it in memory for the entire session, and passes it to whatever signing library you're using. If you're on EVM, you're using ethers.js or viem. If you're also on Solana, you're using

@solana/web3.js with a completely different key format. Bitcoin? Yet another library, another derivation scheme, another set of footguns.

Now you have three private keys, three signing implementations, and three surfaces where those keys can leak — through logs, through crash dumps, through the LLM context window itself if your agent framework isn't careful about what it passes upstream.

Cloud KMS services solve parts of this, but they introduce a different set of tradeoffs: network latency on every signature, a custodial dependency on a third party's infrastructure, vendor lock-in to proprietary APIs, and a recurring cost that scales with transaction volume. For many agent use cases — especially high-frequency micropayments, offline-capable systems, and self-hosted deployments — a cloud round-trip on every sign operation is a nonstarter.

The core issue isn't that nobody's built a wallet before. It's that there's no shared standard for how agent wallets should work.

No common storage format. No common signing interface. No way for a wallet created by one tool to be used by another. Every SDK rolls its own, and the result is private keys scattered across dotfiles, env vars, and proprietary formats with no shared security model.

What we built

**Open Wallet Standard** is an open protocol for local wallet storage and signing, designed for AI agents and the tools that serve them.

The idea is simple: one encrypted vault on your machine, one interface for every chain, and a security model where the private key is never exposed to the agent, the LLM, or any parent process.

Here's what that means concretely.

One mnemonic, every chain.

A single BIP-39 seed phrase derives accounts for all supported chains through standard HD derivation paths - for EVM, solana, bitcoin, tron, ton, cosmos, and more.

One signing interface.

The agent will never see your private key.

One Rust core, every runtime.

The implementation is is entirely written in rust, with node + python bindings.

Encrypted at rest, wiped after signing.

Keys are encrypted with AES-256-GCM using a scrypt KDF — the same Ethereum Keystore v3 format that's been in production since 2015. The key is decrypted only to produce a signature, held in mlocked memory (pinned, never swapped to disk), and zeroized immediately after.

For developers, the interface looks like this:

import { createWallet, signMessage } from "@open-wallet-standard/core";

const wallet = createWallet("agent-treasury");
const sig = signMessage("agent-treasury", "eip155:1", "hello");

Three lines. Native performance. No network calls.

Where it sits in the stack

OWS is not a payment protocol. It's the wallet layer that sits beneath them.

When an x402 server returns a 402 with a payment request, something needs to produce the signed authorization. When an MPP service names a price, something needs to sign the payment. That something is the wallet — and until now, every integration had to build that part from scratch.

OWS gives x402, MPP, A2A, and any future protocol a common wallet to call into. The spec defines seven modules — storage format, signing interface, policy engine, agent access layer, key isolation, wallet lifecycle, and supported chains — so protocol implementers can depend on a well-defined wallet API instead of shipping their own.

The infrastructure shift that makes this inevitable

There's a structural reason local-first wallets are the right model right now, and it's not philosophical — it's architectural.

The way agents are deployed is changing. OpenClaw — the open-source AI agent platform — hit 250,000 GitHub stars in 60 days, making it the fastest-growing open-source project in history. Its entire architecture is local-first: you run it on your own machine or VPS, your data stays on your filesystem, and tool execution happens locally. VPS providers like Hostinger, Contabo, and OVHcloud now offer dedicated OpenClaw hosting plans. Baidu and Tencent are running workshops to help users self-host agents in China. Deloitte projects at least 15% of enterprises will shift to private AI deployments in 2026.

This is the trend: agents are moving from vendor clouds to infrastructure you control. Private VPS instances. Self-hosted runtimes. Local filesystems with shell access and full execution control. When your agent runs on your machine, you have a filesystem. You have memory you control. You have a process boundary you trust.

In that world, cloud wallet providers are solving a problem that doesn't exist. If your agent already runs on your VPS, routing every signing operation through Turnkey's AWS Nitro enclaves or Privy's cloud infrastructure means adding 100-175ms of network latency, a custodial trust dependency on a third party, per-transaction fees, and a hard requirement on network connectivity — all for an operation that takes microseconds locally. You're paying someone to hold your keys on their server when your keys could just live on your server, encrypted, with the same security guarantees and none of the overhead.

Signing is a local operation. The private key, the hash, and the elliptic curve math — that's all local compute. The only network call should be broadcasting the signed transaction to an RPC endpoint.

OWS is built around this reality: your vault lives on your filesystem, signing happens in your process, and the network is only involved when you choose to send.

Why open, why now

Why open: because wallet interoperability requires a shared format.

If Phantom, WalletConnect, Turnkey, and your custom agent framework all store keys differently, you can't move between them without exporting raw key material — which is the exact operation you want to minimize. A CC0-licensed standard with a specified storage format means any tool can read any wallet, and you never have to expose a private key just to switch tools.

Why now: because the number of agents that need wallets is growing faster than the number of wallet standards.

OpenClaw alone has spawned its own wallet ecosystem (agent-wallet-cli, OpenClawCash) — ad hoc solutions built because no standard existed. Every week, a new agent framework ships with its own key management approach. Every proprietary format that gets baked into a production system is another migration someone will eventually have to do. We'd rather standardize this layer now, while the ecosystem is still forming, than try to retrofit a standard after a dozen incompatible approaches have hardened.

The coalition

The @OpenWallet

Standard launched with 21 founding organizations:

  • MoonPay (@moonpay)
  • PayPal (@PayPal)
  • OKX (@okx)
  • Ripple (@Ripple)
  • Tron (@trondao)
  • TON Foundation (@ton_blockchain)
  • Solana Foundation (@solana)
  • Ethereum Foundation (@ethereum)
  • Base (@base)
  • Polygon (@0xPolygon)
  • Sui (@SuiNetwork)
  • Filecoin Foundation (@FilFoundation)
  • LayerZero (@LayerZero_Core)
  • Dflow (@dflow)
  • Uniblock (@Uniblock)
  • Virtuals (@virtuals_io)
  • Arbitrum (@arbitrum)
  • Dynamic (@dynamic_xyz)
  • Allium (@AlliumLabs)
  • Simmer Markets (@simmer_markets)
  • Circle (@circle)

Several are integrating OWS into their SDKs already.

Get started

The standard is live today.

curl -fsSL < https://docs.openwallet.sh/install.sh > | bash

ows wallet create --name "agent-treasury"

Or install the SDK:

npm install @open -wallet-standard/core pip install open-wallet-standard

Read the spec and contribute on

GitHub.

Visit

openwallet.sh to get started.

Follow updates on X at

@OpenWallet.

Every payment protocol needs a wallet underneath it. We think that wallet should be open, local, and the same everywhere.

One vault. One interface. Keys never leave your machine.