MoltPe is AI-native payment infrastructure that gives AI agents isolated wallets with programmable spending policies for autonomous USDC transactions. Below you'll find answers to the most common questions about how it works, security, pricing, and integration.
MoltPe is AI-native payment infrastructure that gives AI agents isolated wallets with programmable spending policies for autonomous USDC stablecoin transactions. It supports multiple protocols including x402 (HTTP-native micropayments), MPP (Machine Payments Protocol), MCP (Model Context Protocol), and REST API. MoltPe is live on Polygon PoS, Base, and Tempo with sub-second settlement and zero gas fees on the free tier.
MoltPe works by creating isolated wallets for each AI agent, each with its own programmable spending policies. Developers set rules like daily limits, approved recipients, and transaction caps. Agents then make autonomous USDC payments within those boundaries using x402, MCP, MPP, or REST API. All transactions settle in sub-second time on supported blockchains with full audit trails.
MoltPe is built for developers integrating payment capabilities into AI agents, teams running autonomous AI workflows that require financial transactions, and businesses deploying AI assistants that need to purchase services or data. It works with Claude Desktop, Cursor, Windsurf, and any AI system that supports MCP, x402, or REST API integration.
Yes. MoltPe offers a free tier that includes zero gas fees for USDC transactions on supported networks. You can create agent wallets, set spending policies, and process payments without upfront costs. The free tier is designed to let developers prototype and deploy AI agent payment workflows before scaling. Visit the dashboard to get started.
Sign up at the MoltPe dashboard to create your account and first agent wallet in minutes. The quickstart guide walks you through wallet creation, funding, spending policy configuration, and making your first transaction. You can integrate via MCP for Claude Desktop and Cursor, x402 for HTTP-native payments, or the REST API for custom implementations.
MoltPe is live on three networks: Polygon PoS, Base, and Tempo. All three support USDC stablecoin transactions with sub-second settlement times and gasless transfers on the free tier. Polygon PoS and Base are established Ethereum Layer 2 networks, while Tempo is optimized for high-throughput machine-to-machine payments. Additional chains may be added based on demand.
Spending policies are programmable rules attached to each agent wallet that govern how funds can be used. You can set daily spending limits, per-transaction caps, approved recipient addresses, and time-based restrictions. Policies are enforced at the infrastructure level before any transaction is signed, so agents cannot exceed their boundaries. Configure policies via the dashboard or API.
x402 is an HTTP-native micropayment protocol that enables AI agents to pay for web resources using standard HTTP headers. When a server returns a 402 Payment Required status, the agent automatically negotiates and completes a USDC payment to access the content. MoltPe fully supports x402, making it easy for agents to pay for APIs, data feeds, and services without custom integration. Learn more in our x402 guide.
MCP (Model Context Protocol) integration lets AI agents running in Claude Desktop, Cursor, or Windsurf access MoltPe wallets as a native tool. Once connected, agents can check balances, send payments, and view transaction history through natural language commands. MoltPe acts as an MCP server that exposes wallet operations as structured tools the AI model can invoke directly.
The MoltPe REST API provides programmatic access to all wallet and payment operations. You can create wallets, set spending policies, send USDC payments, check balances, and retrieve transaction history via standard HTTP endpoints. The API uses JSON request and response formats with API key authentication. Full documentation is available in our guide.
Gasless transactions mean your AI agents can send USDC payments without paying blockchain gas fees. MoltPe sponsors the gas costs on supported networks (Polygon PoS, Base, Tempo) so that agents only need USDC in their wallets to transact. This eliminates the complexity of managing native tokens for gas and reduces costs, especially for high-frequency micropayment workflows.
MoltPe uses a non-custodial architecture with Shamir key splitting to secure wallet private keys. Each key is split into multiple shares distributed across separate secure environments, so no single system ever holds the complete key. Shares are encrypted with AES-256-GCM at rest. This approach ensures that even if one storage layer is compromised, wallet keys remain protected. See our security page for details.
MoltPe uses AES-256-GCM encryption for all data at rest, including wallet key shares and sensitive configuration. All data in transit is protected with TLS 1.3, the latest transport layer security standard. Transaction signing uses EIP-712 typed structured data signatures for on-chain verification. This multi-layer encryption approach meets enterprise security requirements.
Shamir key splitting (also called Shamir's Secret Sharing) is a cryptographic technique that divides a private key into multiple shares. A minimum threshold of shares is required to reconstruct the key, but any fewer shares reveal nothing about the original. MoltPe uses this to ensure no single server or employee can access a wallet's private key, providing non-custodial security without requiring users to manage raw keys. See the glossary for more terms.
Yes. MoltPe logs every wallet operation with full audit trails including timestamps, agent identifiers, transaction amounts, recipient addresses, and policy evaluations. All transactions are also recorded on-chain on the respective blockchain (Polygon PoS, Base, or Tempo) for independent verification. You can view transaction history in the dashboard or retrieve it programmatically via the REST API.
MoltPe maintains a transparent security posture. Our security practices, architecture details, and vulnerability disclosure policy are published at moltpe.com/security. The system is designed with defense in depth: non-custodial Shamir key splitting, AES-256-GCM encryption, TLS 1.3, EIP-712 signatures, and programmable spending policies that limit blast radius even if an agent is compromised.
You can create an agent wallet in seconds through the MoltPe dashboard or programmatically via the REST API. Each wallet is isolated with its own address, balance, and spending policies. Give each agent its own wallet to maintain separation of concerns and clear audit trails. The quickstart guide covers wallet creation step by step.
Fund an agent wallet by sending USDC to the wallet's address on any supported network (Polygon PoS, Base, or Tempo). You can transfer USDC from any external wallet or exchange that supports these networks. The deposit appears in the agent's balance within seconds. The dashboard displays each wallet's address and current balance for easy management.
Yes. Daily spending limits are one of the core spending policy features in MoltPe. You set a maximum USDC amount an agent can spend per 24-hour period, and the infrastructure enforces it automatically. If an agent attempts a transaction that would exceed the limit, the transaction is rejected. You can adjust limits anytime via the dashboard or API without creating a new wallet.
Yes. Every MoltPe agent wallet has a standard blockchain address that can receive USDC from any source, including other agents, users, or external wallets. This enables use cases like AI agents that earn revenue by selling services, data, or API access. Incoming payments are reflected in the wallet balance immediately and appear in the transaction history with full details.
Agent-to-agent payment is when one AI agent sends USDC directly to another AI agent's wallet without human intervention. MoltPe enables this through all supported protocols: x402, MCP, MPP, and REST API. This powers autonomous workflows like an AI research agent paying a data-provider agent for information, or a coordinator agent distributing funds to task-specific sub-agents.
Coinbase Agentic Wallets pioneered x402 and have processed over 50 million transactions. MoltPe differentiates with programmable spending policies that give developers granular control over agent behavior, non-custodial Shamir key splitting for wallet security, and multi-protocol support (x402, MCP, MPP, REST API). MoltPe also offers gasless transactions and supports Polygon PoS, Base, and Tempo networks.
MoonPay's Open Wallet Standard is an open-source framework supporting 8 chain families with broad wallet interoperability. MoltPe takes a different approach, focusing specifically on AI agent payment workflows with built-in spending policies, sub-second USDC settlement, and native MCP integration for Claude Desktop and Cursor. MoltPe is purpose-built for autonomous AI transactions rather than general wallet infrastructure.
Regular crypto wallets lack the controls needed for autonomous AI agents. Without spending policies, a compromised or malfunctioning agent could drain the entire wallet. MoltPe provides programmable limits, isolated per-agent wallets, audit trails, non-custodial key management via Shamir splitting, and gasless USDC transactions. These features prevent runaway spending and provide the oversight required for production AI deployments.
Building custom payment infrastructure for AI agents requires solving key management, gas sponsorship, spending controls, multi-chain support, and audit logging from scratch. MoltPe provides all of this out of the box with a free tier, plus native integrations for x402, MCP, MPP, and REST API. Teams typically go from zero to working agent payments in under an hour instead of weeks of custom development.
Check out our documentation for detailed guides, or jump straight into the dashboard to start building.
Get Started Free →MoltPe is AI-native payment infrastructure that gives AI agents isolated wallets with programmable spending policies for autonomous USDC transactions. Live on Polygon PoS, Base, and Tempo. Built by the team behind Cray.