A steel vault door inside a server aisle, separated by dark glass from a cluster of glowing compute units.

Custody for Machines: Who Holds the Agent's Keys

MoonPay launched the Open Wallet Standard in March 2026, but agent wallets still split on where policy is enforced: on-chain or via vendor API.

17 min read
Share X LinkedIn

cover

Introduction

MoonPay open-sourced the Open Wallet Standard in March 2026, presenting it as a way for AI agents to hold value, sign transactions, and pay for services across major chains without a private key ever being exposed. The announcement MoonPay published contains no policy-engine specification, no session-key format, no interop test, and no list of the 15-plus backers attributed to the effort in secondary coverage. We could not verify the backer roster, which has been reported to include PayPal, Circle, and the Ethereum and Solana Foundations, from MoonPay’s own text.

That gap matters more than it looks. Keeping a private key out of a language model’s context window is the easy half of agent custody, and every serious vendor already does it with hardware enclaves, split-key schemes, or scoped signing keys. The hard half is enforcing the rule that stops a bad transaction in a place the model cannot influence. On this axis the vendors genuinely diverge, and no amount of shared vocabulary closes the gap.

An agent wallet is a keypair whose signing authority is exercised by software acting on a model’s output rather than by a human reviewing a transaction before approving it. Remove the human from the approval step and the security question changes shape. A human wallet fails when someone steals the seed phrase. An agent wallet fails when the model is persuaded, by a poisoned web page, a malicious tool response, or a compromised orchestration server, to authorize a transaction it was technically permitted to sign.

Across the stacks that six vendors have built around that problem, the decisive distinction lies in where rules are executed rather than which key-storage primitive was selected. Openfort’s comparison of the field draws the line in a sharper place: policy enforced on-chain through a smart account and scoped session keys is independently verifiable by any third party, while policy checked by the provider’s API before it signs is only as good as the provider’s server behaving correctly. The first survives a vendor you do not trust. The second does not.

Figures circulating for x402 buyer counts, on the order of several hundred thousand distinct buyers, are not something we can confirm against a primary source, so we leave them out of the argument. Adoption scale would not settle the custody question in any case. Volume moving through machine-held wallets tells us nothing about where policy was enforced for any of it.

What a key held by software has to survive

The threat model for agent wallets inherits almost nothing from human wallet security except the key material itself. Openfort’s comparison frames agent key leakage as a distinct category, arriving through prompt injection, poisoned tool results, or a compromised orchestration server rather than through phishing a seed phrase. The practical consequence is that the attacker’s goal shifts. Stealing the key is optional if the key can be made to sign on command.

Three failure categories follow, and they are not equally well addressed.

The first is direct key exfiltration: the model, or the application code around it, gains access to raw key material and leaks it into a log, a tool call, or a response. Every architecture in this comparison is built to eliminate this category, and on the evidence available, they mostly succeed. Keys live in trusted execution environments, in HSM-protected envelopes, or as shares that are never reassembled.

The second is authority abuse within granted scope. The agent still holds legitimate signing authority. An injected instruction causes it to use that authority for the attacker’s benefit, sending permitted amounts to permitted contracts in an impermissible sequence. Spend caps and allowlists are the designed defense, and they are partial.

The third is authority escalation: the policy inputs themselves are subverted. If the component that tells the enclave what the policy is can be influenced by the same pipeline the attacker controls, then isolating the key accomplishes less than the marketing implies. None of the sources we reviewed describe a vendor explicitly designing against this case, which is the more interesting half of the research question.

A TEE prevents the first category by construction. It has nothing to say about the second or third unless the policy evaluated inside it is itself fixed outside the agent’s reach.

Four ways to keep a key out of the model’s context

img1

Four key-storage mechanisms recur across the field, and they solve the same narrow problem with different trust assumptions. Openfort’s survey of agent wallets for developers identifies all four, and Cobo’s comparison of agentic wallets for traders maps overlapping territory with different vendor attributions.

Trusted execution environments with remote attestation generate and hold the key inside a hardware-isolated enclave, so neither the agent code nor the model sees raw key material. Remote attestation lets a relying party check which code is running inside the enclave before trusting it with anything. Cobo attributes TEE isolation to Coinbase AgentKit and OKX; Openfort describes Turnkey as enforcing policy inside a secure enclave at the curve layer, meaning the signing operation and the rule check happen in the same protected boundary.

Envelope encryption protects wallet secrets with a data encryption key, which is itself protected by a key encryption key held in an HSM. Openfort describes using this per wallet alongside a TEE. The property it gives is operational rather than cryptographic novelty: compromising stored ciphertext at rest is insufficient without separate access to the HSM.

Secret sharing and MPC split signing authority so that no single party can produce a valid signature. Cobo’s own design splits signing into two groups, Agent plus Cobo for transactions authorized under its Pact system, and Human plus Cobo for high-value approvals, which preserves a human recovery path even while the agent operates autonomously. Privy is described as combining Shamir-style secret sharing with a TEE.

Session keys take a different approach entirely. A session key is a disposable, scoped keypair authorized to act within explicit limits: specific contracts, specific methods, a spend cap, and an expiry window. The agent signs with the session key and never holds the wallet’s root authority. Openfort places session keys on-chain in a smart account, which is the property that distinguishes them from the other three mechanisms.

VendorPrimary custody primitiveWhere policy is checkedBasis
OpenfortTEE plus per-wallet envelope encryptionOn-chain session keys in a smart accountOpenfort self-reported, 2026
TurnkeySecure enclaveInside the enclave at the curve layerOpenfort comparison, 2026
PrivySecret sharing plus TEENot specified in sourcesOpenfort and Cobo, 2026
CrossmintDual-key, TEE-sealed agent keysApproval flows; GOAT framework is wallet-agnosticOpenfort and Cobo, 2026
Coinbase AgentKitTEE isolationContradicted across sources (see below)Openfort and Cobo, 2026
CoboMPC split across Agent+Cobo and Human+Cobo groupsPact task approval before executionCobo self-reported, 2026
MoonPayNot specified; hardware-backed approval via Ledger claimedNot specifiedMoonPay announcement

Every row of that table comes from vendor-published material. Two of the three sources behind it are companies ranking themselves against competitors. The contradiction is visible in the AgentKit row: Openfort’s comparison states that Coinbase AgentKit has no built-in spending controls, while Cobo’s comparison states that AgentKit enforces session caps, per-transaction caps, and allowlisted contracts at the TEE level so agents cannot bypass them programmatically, alongside KYT screening and native x402 support. Both cannot be describing the same configuration. Either the product changed quickly, or the comparisons are scoped differently, or at least one is wrong. We have no independent audit that resolves it, and the same uncertainty attaches in principle to every other row.

On-chain enforcement versus a vendor’s API call

img2

The location of the policy check determines who has to be trusted, and it is the only axis in this comparison with a clean verification story. Openfort’s framing is that on-chain policy, expressed as session-key constraints inside a smart account, is fail-closed and independently verifiable: a third party can read the account’s state and confirm what the agent is permitted to do without asking the vendor anything. Off-chain policy, checked by the provider’s API before the provider signs, offers no such check. The constraint exists in server code that outsiders cannot inspect and that the vendor can change.

Three consequences follow from that difference.

A vendor running off-chain policy can be compelled, bribed, breached, or simply buggy, and the failure is invisible from outside until funds move. On-chain constraints fail closed by default: a transaction violating a session key’s scope reverts, whether or not the vendor is cooperating.

Off-chain policy also sits inside the request path that the agent itself populates. If the policy check reads parameters assembled by the same pipeline an attacker has influence over, the separation between model and enforcement is thinner than the architecture diagram implies. On-chain constraints are set once by the account owner and are not re-derived from agent-supplied context on each call.

The tradeoff runs the other way on expressiveness. An off-chain engine can evaluate anything: counterparty risk scores, KYT screening results, time-of-day rules, aggregate exposure across chains. Cobo’s Pact system requires explicit approval of intent, execution plan, policies, and completion conditions for each agent task, with a denial path that returns a structured reason so the agent can self-correct and retry rather than halting for human re-intervention. None of that fits inside a session-key scope expressed on-chain. The richer the policy, the more likely it lives somewhere a third party cannot verify.

The honest position is that the two are complementary and that vendors should be judged on what survives when the off-chain layer is gone. A stack with rich off-chain screening and no on-chain backstop degrades to full agent authority the moment the policy server is compromised. A stack with on-chain session keys degrades to the session key’s scope, which is bounded but not safe.

Jailbreak and compromise are different failures

img3

The phrase “keys never touch the LLM” answers the wrong question for the two threats that actually matter. Both involve a key the model never sees.

A jailbreak or prompt injection leaves the authority structure intact. The agent holds a session key scoped to three contracts with a daily cap, and an attacker convinces it to use that authority badly. Every permitted transaction remains permitted. Spend caps bound the damage per window, and allowlists bound the destination set, but neither constrains the economic outcome of a permitted call. An allowlist authorizes a contract address and a method, not a price. An agent permitted to swap on an allowlisted venue can be induced to swap at a ruinous rate, or into a token the allowlist never contemplated because the allowlist governs the router, not the asset on the other side. A cap denominated in outbound stablecoin stops the outflow at a number. It does not stop the loss.

Full model compromise is the harder case, and it is the one the available sources do not address. If the attacker controls the orchestration layer rather than merely feeding it bad text, the question becomes whether the policy inputs are also under attack. In an architecture where the enclave evaluates a policy loaded at wallet creation and signed by the human owner, the answer can be no. In an architecture where policy is fetched per request from a service the compromised orchestrator talks to, the answer is probably yes. Openfort’s distinction between fail-closed on-chain enforcement and API-checked policy is the closest thing to an answer available, and it only covers the final signing gate.

Rate of harm matters as much as the bound on harm. A compromised agent operating inside a legitimate session cap can issue transactions continuously until the key expires or someone revokes it. Whether the resulting loss is a rounding error or the whole balance depends on the ratio between the cap window and the detection-to-revocation latency, a figure no vendor in our sources publishes. A daily cap means little if compromise persists for six days and the revocation path requires a human to notice.

Cobo’s two-group MPC split is the most structurally interesting response to this case. Routing high-value transactions through a Human plus Cobo signing group means the agent’s compromise cannot by itself produce a signature above the threshold, regardless of what the model believes. The threshold becomes the real security boundary, and everything below it is accepted loss. MoonPay’s claim that MoonPay Agents was the first agent-focused wallet with hardware-backed Ledger approval points in the same direction, and carries the same cost: a hardware confirmation step reinserts a human at precisely the moment autonomy was supposed to remove one. That is a defensible tradeoff, but it should be priced as one rather than presented as pure gain.

Delegation chains and the intersection problem

img4

Nothing in the available sources documents how spend caps and allowlists compose when one agent delegates to another, which makes the multi-hop case the least evidenced part of an otherwise well-mapped design space. The primitives differ in whether they can compose at all, and that difference is structural rather than a matter of implementation quality.

Allowlists compose cleanly. A sub-agent’s permitted contract set should be a subset of its parent’s, and set intersection is stateless, order-independent, and checkable at any hop. Expiry composes almost as cleanly: the effective deadline is the minimum across the chain, and a sub-key outliving its parent is straightforwardly a bug.

Spend caps do not compose this way. A cap is a stateful budget, not a static permission. If a human grants an agent $10,000 per day and that agent issues three sub-keys each capped at $10,000, the constraint has silently tripled unless all three draw from a shared counter. Enforcing a shared counter requires a single accounting point that every hop consults before signing. An on-chain smart account can be that point, because the contract holds the running total and rejects the transaction that breaches it. An off-chain policy service can also be that point, provided every delegate routes through it, which reintroduces the trust dependency the on-chain design was meant to remove.

The composition question therefore resolves into an architectural one: does the chain of delegation converge on a single enforcement point that holds the budget state, or does each hop carry an independently enforced copy of a limit? Only the first is sound. The second produces caps that multiply with the number of delegates, which is the opposite of what a cap is for.

Crossmint’s GOAT framework sits awkwardly against this requirement. The framework is MIT-licensed and deliberately wallet-agnostic, compatible with Coinbase CDP, Lit Protocol, and custom key management across more than 30 chains per Crossmint’s own description. Agnosticism is useful for integration and corrosive for policy composition: if two hops in a delegation chain use different custody backends with different enforcement points, there is no shared counter to consult and no reason to expect the limits to intersect correctly. This is exactly where a standard would earn its name, and exactly where we have no evidence that one exists.

We found no source documenting a production deployment of multi-hop agent delegation with enforced cap composition. Claims about how these systems behave under delegation should be read as design intent.

Revocation is the least documented part of every stack

img5

Openfort’s comparison states plainly that key rotation and revocation are the least documented part of most vendors’ stacks, and our reading of the other sources supports that. Custody architectures are described in detail up to the moment of compromise and go quiet immediately after.

The omission is consequential because revocation latency, not cap size, determines realized loss in the compromise scenarios described above. Three mechanisms would need to be specified before any of these systems can claim graceful compromise handling, and none is specified in public material we reviewed.

The first is propagation. Revoking an on-chain session key is a transaction, which means it inherits block times, gas conditions, and the possibility that the compromised agent is competing for inclusion in the same blocks. Revoking an off-chain credential is a database write, which is faster, and which the compromised orchestration layer may be positioned to observe or outrace. Neither path has published latency figures.

The second is scope. Revoking one session key in a delegation tree does not obviously revoke its descendants, and whether descendants are invalidated by their parent’s revocation depends on whether the chain is verified at signing time or merely at issuance time. A system that checks only the immediate key’s validity leaves orphaned sub-keys signing after the root authority is gone.

The third is what audit logs are actually for. Every vendor in this comparison offers them. The open question is whether logs are a control or a record. A control triggers automatic revocation when a pattern crosses a threshold, which requires the log pipeline to be trusted and independent of the agent, and which introduces its own false-positive risk against an autonomous system with no human watching. A record enables post-hoc reconstruction after the funds are gone. The sources describe logging as a feature without distinguishing the two, and the difference is the entire security value of the feature.

Standard, or shared vocabulary

Calling the Open Wallet Standard a standard currently overstates what has been demonstrated. MoonPay’s stated goal is to make the infrastructure available to “every agent, every framework, and every chain,” and the announcement positions the standard as universal rather than tied to a single vendor’s stack. Universality is a claim about interoperation, and interoperation is testable. No test, reference implementation detail, or policy schema appears in the announcement text.

A standard that constrains implementations in this domain would have to define at minimum: a schema for expressing spend caps, allowlists, and expiry that two independent wallets interpret identically; a rule for how those constraints compose across a delegation hop; a canonical way for a relying party to verify a given agent’s current authority without querying the agent’s own vendor; and a revocation message format that propagates across implementations. Each of these is checkable. None is described.

What the vendor material does show is genuine architectural divergence underneath identical terminology. MPC with human-threshold signing groups, TEE isolation at the curve layer, envelope encryption, multisig smart accounts, and on-chain session keys are different trust models with different failure boundaries, and a shared glossary does not make them substitutable. Two wallets that both advertise “spend caps” may enforce them in a contract that reverts or in a server that returns a 403, and only one of those survives the vendor going offline.

The more plausible near-term reading is that the Open Wallet Standard standardizes the integration surface, which is useful, while leaving the enforcement semantics to each implementation, which is where the risk lives. That would still be worth doing. It is a different thing from what the name implies, and buyers evaluating agent custody should not let the second substitute for the first.

What would make these claims checkable

The entire comparison above rests on documents written by companies describing their own products and ranking competitors. Two of our three sources are vendor blogs. The one direct contradiction we found, on whether Coinbase AgentKit enforces spending controls at the TEE level or has no built-in spending controls at all, is unresolvable from public material, and its existence should lower confidence in every uncontested claim as well.

Four things would change that, and all are within reach of the vendors involved. Published remote-attestation measurements that a third party can verify against open-source enclave code would turn “keys never leave the TEE” from an assertion into a check. Revocation latency figures under adversarial conditions, measured from detection to the last signature a revoked key could produce, would make the gap between cap size and realized loss measurable. A machine-readable policy schema with cross-implementation test vectors would show whether the standard constrains anything. And independent penetration results against the policy engines, specifically for prompt injection and orchestration-layer compromise rather than key extraction, would test the threat model everyone describes and nobody has published results against.

Until then, the defensible position for anyone sizing exposure to a machine-held wallet is to treat the on-chain, fail-closed portion of the policy as the real limit and everything above it as a convenience that assumes a cooperative vendor. The practical questions follow from that: what is the worst outcome if the agent signs every transaction its session key permits, in the worst order, for the full window before anyone intervenes, and who absorbs that loss. Vendors that can answer the second question contractually are making a stronger statement about their architecture than any of the terminology in this comparison.

References

Read next

Follow the next market structure breakdown

New Steadyrain research is published several times a week across DeFi risk, BTCFi, stablecoins, and RWA.