AI Agent Wallets Compared: AgentKit vs Crossmint vs NEAR
Compare AI agent wallet infrastructure by autonomy level, policy controls, supported chains, and security model. Coinbase AgentKit, Crossmint, NEAR, Lit Protocol, Cobo CAW.
AI Agent Wallet Infrastructure Compared
AI agents that can transact on-chain need wallets purpose-built for autonomous operation. Standard embedded wallets assume a human clicks "confirm" before every transaction. Agent wallets replace that confirmation step with programmable policy controls: spend limits, recipient allowlists, and circuit breakers that enforce guardrails at the infrastructure layer rather than relying on the AI's judgment.
Five platforms have emerged as the primary options for developers building agentic wallets: Coinbase AgentKit (and Agentic Wallets), Crossmint, NEAR AI, Lit Protocol, and Cobo Agentic Wallet (CAW). They differ in security model, chain coverage, policy enforcement, and SDK maturity. The following comparison is based on publicly available documentation and product announcements as of late 2026.
| Platform | Security Model | Chains | Policy Enforcement | SDK Languages | Open Source |
|---|---|---|---|---|---|
| Coinbase AgentKit | MPC (CDP infrastructure) | Base, Ethereum, Arbitrum, Polygon, Solana | Session caps, per-tx limits | TypeScript, Python | Yes |
| Crossmint | Smart contract wallet + TEE signer | 50+ (EVM, Solana, Stellar) | On-chain rules, dual-key model | TypeScript | No |
| NEAR AI | TEE enclaves (Shade Agents) | NEAR, 35+ via Intents | On-chain guardrails, escrow | Rust, TypeScript | Yes |
| Lit Protocol | Programmable Key Pairs (distributed nodes) | EVM chains, Solana | Lit Actions (code-based conditions) | TypeScript | Yes |
| Cobo CAW | MPC (institutional custody) | 80+ blockchains | Pact protocol, 3-layer policy engine | TypeScript, Python | No |
Security Models: MPC vs Smart Contract vs TEE
The core design decision for any agentic wallet is where the signing key lives and who controls it. Three architectures dominate the space, each with distinct trust assumptions.
MPC-Based Agent Wallets
Multi-party computation splits a private key into multiple shares distributed across separate parties. No single share can produce a valid signature alone. Coinbase AgentKit and Cobo CAW both use this model. Coinbase keeps key shares in secure CDP infrastructure, isolated from the agent's prompt context and LLM. Cobo splits shares between the user and Cobo's infrastructure, with a policy engine that validates every transaction against the agent's "Pact" before MPC signing proceeds.
The advantage of MPC is that a compromised agent cannot extract a usable key: even if the agent's share is leaked, the remaining shares remain in separate secure enclaves. The tradeoff is reliance on the MPC provider's infrastructure and availability.
Smart Contract Wallets
Crossmint deploys smart contract wallets with a dual-key architecture. An owner key stays with the user or team, while a separate agent key is sealed inside a trusted execution environment. Policy limits such as per-transaction caps, rolling spending windows, and recipient allowlists are enforced by the smart contract itself. Because the rules live on-chain, they cannot be bypassed even if the agent is fully compromised.
The tradeoff is that smart contract wallets are chain-specific: each supported chain needs its own wallet deployment, and non-EVM chains require different implementations. Crossmint abstracts this behind a unified API, but the underlying complexity affects gas costs and deployment latency.
TEE and Distributed Key Approaches
NEAR AI runs agents inside trusted execution environments through its Shade Agent framework. The TEE isolates the agent's signing capability from external access, and persistent NEAR accounts provide on-chain guardrails around agent actions. Lit Protocol takes a different path: Programmable Key Pairs distribute key material across Lit's node network, and "Lit Actions" (JavaScript functions executed on Lit nodes) define the conditions under which signing can occur.
Supported Actions
An agent wallet is only useful if the agent can actually do things with it. The following table compares which on-chain actions each platform supports natively through its SDK.
| Action | Coinbase AgentKit | Crossmint | NEAR AI | Lit Protocol | Cobo CAW |
|---|---|---|---|---|---|
| Token Transfer | Yes | Yes | Yes | Yes | Yes |
| Token Swap | Yes (Base) | Yes | Yes (via Intents) | Custom Lit Actions | Yes |
| Cross-Chain Bridge | Limited | Yes | Yes (Intents) | Custom Lit Actions | Yes |
| Staking | Via Staking API | No | Yes (NEAR native) | Custom Lit Actions | Yes |
| NFT Mint | Yes | Yes | Yes | Custom Lit Actions | No |
| Smart Contract Deploy | Yes | No | Yes | Custom Lit Actions | No |
| API Payments (x402) | Yes | Yes | No | No | No |
| Fiat On-Ramp | Yes (Coinbase) | Yes (card, Apple Pay) | No | No | No |
Coinbase AgentKit provides 50+ built-in action providers, with framework integrations for LangChain, Vercel AI SDK, and Model Context Protocol. Crossmint offers a broad action set through its unified API, with native support for the x402 protocol for agentic payments to offchain APIs. NEAR AI routes complex multi-chain actions through its Intents system, which has processed over $24 billion in cross-chain volume. Lit Protocol requires developers to write custom Lit Actions for anything beyond basic signing, which provides maximum flexibility at the cost of development time. Cobo CAW integrates with LangChain, OpenAI Agents SDK, Claude MCP, and CrewAI, and supports over 3,000 tokens across its 80+ chains.
Policy Guardrails: Preventing Fund Drainage
The critical question for any wallet spending policy in an agent context is: what happens if the agent malfunctions, gets prompt-injected, or hallucinates a transaction? Without infrastructure-level enforcement, a compromised agent with signing authority can drain its wallet in seconds. For a detailed analysis of these attack vectors, see our research on AI wallet security attack surfaces.
Each platform approaches this problem differently:
- Coinbase Agentic Wallets enforce programmable session caps and per-transaction limits at the CDP infrastructure layer. The agent never touches the raw key material.
- Crossmint enforces policy at the smart contract level with a dual-key model: the agent key can only operate within the bounds set by the owner key. Recipient allowlists and rolling spend caps are checked on-chain before execution.
- Cobo CAW uses a three-layer policy engine (global, wallet, and delegation) that validates every transaction against the agent's Pact before MPC signing. Circuit breakers can pause the wallet automatically when velocity limits are exceeded.
- NEAR AI enforces guardrails through on-chain account permissions and an escrow system in its Agent Market, where tasks and payments are released only upon verified completion.
- Lit Protocol enforces conditions through Lit Actions: code that runs on Lit's distributed node network and must evaluate to true before the key shares will participate in signing.
For a deeper dive into how these policy architectures work and their trust assumptions, see our research on AI agent wallet policy architecture.
Developer Experience and SDK Quality
SDK quality matters as much as the underlying security model when choosing an agent wallet platform. A poorly documented SDK creates integration risk that can be worse than the security risks it aims to prevent.
Coinbase AgentKit ships as npm packages (@coinbase/agentkit, @coinbase/agentkit-langchain, @coinbase/agentkit-vercel-ai-sdk) in both TypeScript and Python. It offers the most framework integrations of any agent wallet platform, with direct support for LangChain, Vercel AI SDK, and MCP. The legacy @coinbase/cdp-agentkit-core packages are deprecated.
Crossmint provides a TypeScript SDK with a single API surface covering wallet creation, transaction signing, and policy management across all supported chains. Its proprietary infrastructure means you cannot self-host the signer, which is a constraint for teams that need full custody control.
NEAR AI development uses Rust for on-chain contracts and TypeScript for agent orchestration. The Shade Agent framework and Intents system are open source, though the documentation is spread across multiple repositories and is less consolidated than Coinbase's or Crossmint's offerings.
Lit Protocol requires learning its Lit Actions paradigm: JavaScript functions that run on Lit's node network. The original Lit Agent Wallet has been deprecated in favor of Vincent, a newer architecture. Developers should check current Lit documentation for the latest integration path.
Cobo CAW integrates with five major agent frameworks (LangChain, OpenAI Agents SDK, Claude MCP, Agno, CrewAI) and provides both TypeScript and Python SDKs. As of late 2026, access remains invite-only, which limits broader developer adoption.
How to Choose an AI Agent Wallet
The right platform depends on your chain requirements, security needs, and development constraints. For a broader comparison of wallet SDKs beyond the agent-specific use case, see our embedded wallet comparison.
If you need broad EVM and Solana support with a mature SDK: Coinbase AgentKit offers the strongest framework integrations and the most battle-tested MPC infrastructure. Its open-source codebase means you can audit the action providers and customize behavior.
If you need maximum chain coverage with minimal code: Crossmint's 50+ chain support and unified API make it the fastest path to a multi-chain agent. The tradeoff is vendor lock-in to Crossmint's proprietary infrastructure.
If you need cross-chain intents and an agent marketplace: NEAR AI provides a unique intent-based architecture where agents can discover tasks, bid on work, and settle payments across 35+ chains through a single protocol.
If you need maximum policy flexibility: Lit Protocol's code-as-policy model lets you define arbitrary signing conditions. Any check you can express in JavaScript can gate a transaction. This is powerful but requires more development effort than pre-built policy engines.
If you need institutional-grade custody for high-value operations: Cobo CAW extends a proven institutional custody platform to the agent use case. Its three-layer policy engine and 80+ chain support make it suited for treasury operations, though invite-only access is currently a barrier.
For agents operating in the Bitcoin ecosystem, the landscape is still developing. Most agent wallet platforms focus on EVM chains and Solana. Spark enables instant Bitcoin and stablecoin transfers that could serve as settlement rails for agent-to-agent payments on Bitcoin. For more on how AI agents interact with crypto payment infrastructure, see our research on AI agents and crypto payments.
Frequently Asked Questions
Can I let an AI agent manage my Bitcoin?
Technically yes, but the tooling is limited. Most agent wallet platforms (Coinbase AgentKit, Crossmint, Cobo CAW) focus on EVM chains and Solana. NEAR AI provides cross-chain capabilities via Intents. For Bitcoin-native operations, you would need to combine an agent framework with a Bitcoin-compatible MPC wallet or use a Layer 2 like Spark for fast settlement. No major agent wallet platform currently offers native UTXO-based Bitcoin signing with agent-specific policy controls.
What happens if the AI agent malfunctions?
The answer depends entirely on the policy guardrails in place. Well-configured agent wallets limit the blast radius: per-transaction caps ensure a single bad transaction cannot drain the wallet, velocity limits catch repeated small transactions, and circuit breakers can freeze the wallet when anomalous behavior is detected. Without these guardrails, a hallucinating or prompt-injected agent with unrestricted signing authority could drain funds in seconds. The key principle is that policy enforcement must happen at the infrastructure layer, not inside the agent's code, since the agent itself may be compromised.
What is the difference between MPC and smart contract agent wallets?
MPC wallets split the private key into shares held by separate parties, so no single party can sign alone. Policy is enforced by the MPC provider before combining shares. Smart contract wallets keep the key in a TEE or secure enclave and enforce policy through on-chain code. MPC wallets work across any chain (including non-smart-contract chains), while smart contract wallets offer on-chain verifiability of policy rules but are limited to chains that support programmable accounts.
How do agent wallet spending policies prevent prompt injection attacks?
Spending policies operate outside the agent's execution context. Even if an attacker successfully injects a malicious prompt that instructs the agent to send all funds to an attacker address, the infrastructure layer checks the transaction against predefined rules before signing. A recipient allowlist would reject the unknown address. A per-transaction cap would limit the amount. A velocity limit would block rapid successive transactions. The policy engine has no awareness of the agent's prompt, so it cannot be manipulated through the same vector.
Which AI agent wallet has the best multi-chain support?
Cobo CAW supports the most chains at 80+ blockchains and over 3,000 tokens. Crossmint follows with 50+ chains across EVM, Solana, and Stellar. NEAR AI reaches 35+ chains through its Intents cross-chain protocol. Coinbase AgentKit supports fewer chains directly (Base, Ethereum, Arbitrum, Polygon, Solana) but benefits from deep integration with Coinbase's infrastructure. Lit Protocol supports EVM chains and Solana through its distributed signing network.
Is Coinbase AgentKit the same as Coinbase Agentic Wallets?
No. AgentKit is the open-source SDK that defines agent actions (transfer, swap, deploy contracts) and provides framework integrations with LangChain and Vercel AI SDK. Agentic Wallets is a separate product launched in February 2026 that provides MPC-secured wallets with programmable session caps, spend limits, and native x402 support. AgentKit handles what the agent can do; Agentic Wallets handle the signing authority and custody. Developers typically use both together.
Are AI agent wallets safe for managing large amounts of crypto?
Agent wallets are still a nascent category, and no platform has a long track record of securing large autonomous treasuries. For high-value use cases, Cobo CAW builds on institutional-grade MPC custody with multi-layer policy enforcement. The general recommendation is to fund agent wallets with only the amount needed for near-term operations, use session keys with time-limited permissions, and keep the majority of funds in a separate cold storage wallet that the agent cannot access.
This tool is for informational purposes only and does not constitute financial or security advice. Product features, chain support, and access availability change frequently. Data is based on publicly available documentation and announcements as of late 2026. Always verify current capabilities against official vendor documentation before making architectural decisions.
Build with Spark
Integrate bitcoin, Lightning, and stablecoins into your app with a few lines of code.
Read the docs →
