Capri Ai Agentpay

Capri AgentPay is a governed payment layer purpose-built for AI agents that need to autonomously call paid APIs, settle microtransactions, and interact with stateful infrastructure without the catastrophic risk of exposing private keys. As autonomous agents become more capable, the traditional approach of handing them a cryptographic key creates an unacceptable security vulnerability: a single malicious or poorly constructed prompt can drain an entire wallet. Capri solves this by inserting a runtime policy engine between the agent and the signing mechanism. When an agent encounters an HTTP 402 Payment Required challenge from a paid endpoint, Capri intercepts the request and evaluates it against a fixed, deterministic policy chain. This chain checks merchant allowlists, per-transaction caps, daily budget limits, and an auto-approve threshold that can pause for human review. Only when every policy check passes does Capri settle the payment, retry the original request with cryptographic proof attached, and store a signed receipt that can be verified offline. The product is designed for engineering teams shipping agent systems in production environments where budgets, compliance, and audit trails are non-negotiable. It provides six Model Context Protocol (MCP) tools instead of raw key access, a VS Code extension for developer workflow integration, and a Base Sepolia sandbox for testing settlement logic. Capri AgentPay transforms the dangerous act of letting agents spend money into a controlled, observable, and policy-governed operation that security teams can trust.

Governed Payment Policy Engine

Capri AgentPay enforces a strict, fixed-order policy chain that evaluates every payment request before any signature is created. The policy begins with a merchant allowlist to restrict which endpoints can receive funds, then checks per-transaction caps to prevent excessive single payments, followed by daily budget limits to control aggregate spending. Finally, an auto-approve threshold allows small, low-risk transactions to proceed automatically while flagging larger ones for human-in-the-loop review. This layered approach ensures that agents can operate autonomously within safe boundaries without creating a security nightmare for operators.

X402 Payment Handling and Receipts

The product natively handles the HTTP 402 Payment Required status code, which is the emerging standard for machine-to-machine payments. When an agent calls a paid API and receives a 402 challenge, Capri automatically intercepts, evaluates the policy, and if approved, settles the payment on-chain. It then retries the original request with a proof-of-payment attached. Every successful transaction generates a signed receipt containing hashes, timestamps, chain details, and verification fields that can be independently verified offline, providing a complete audit trail for compliance and accounting.

Six MCP Tools Instead of Raw Key Access

Instead of giving agents direct access to private keys or signing capabilities, Capri provides six carefully designed Model Context Protocol tools. These tools expose only the specific operations needed for payment handling: initiating payments, checking budgets, reviewing transaction history, managing policies, retrieving receipts, and querying merchant allowlists. This narrow surface area dramatically reduces the attack surface and ensures that agents can only perform authorized actions within the boundaries defined by the operator. It also simplifies integration with existing agent frameworks.

Human-in-the-Loop Approval Workflow

For transactions that exceed the auto-approve threshold, Capri AgentPay introduces a human-in-the-loop review process. Operators see a clear interface showing the exact amount, asset, chain, and recipient before making an approval decision. The interface also displays which policy branch passed or failed, giving full context for the decision. This workflow allows teams to start with tight controls and gradually increase autonomy as they build trust in their agent systems, without ever sacrificing security or operational oversight.

Autonomous Research Agents Accessing Premium Data APIs

Research agents that need to query paid data sources, such as financial market feeds, scientific databases, or proprietary analytics APIs, can use Capri AgentPay to handle payments autonomously. The agent can call multiple premium endpoints, and Capri will manage the 402 challenges, check budgets, and settle payments without exposing API keys or wallet credentials. Operators can set daily research budgets and merchant allowlists to ensure spending stays within approved limits, while signed receipts provide a clear audit trail for cost allocation and compliance.

Agentic Workflows for Internal Tool and Infrastructure Access

Teams building agent systems that need to interact with internal paid services, cloud APIs, or third-party SaaS tools can use Capri to govern spending. For example, an agent that generates marketing reports might need to call a paid image generation API and a data enrichment service. Capri ensures that each call is policy-checked, budget-capped, and recorded. This allows engineering teams to deploy agents that interact with real paid infrastructure without the fear of runaway costs or unauthorized usage.

Decentralized Finance (DeFi) and On-Chain Transaction Agents

Agents operating in decentralized finance environments that need to settle microtransactions, pay gas fees, or interact with smart contracts can use Capri AgentPay as a secure payment layer. The product's Base Sepolia sandbox allows teams to test settlement logic in a controlled environment before going to mainnet. The governed runtime ensures that agents can execute on-chain operations only within defined policy boundaries, preventing catastrophic errors from a single bad prompt while maintaining the speed and autonomy needed for DeFi operations.

Enterprise Compliance and Audit-Ready Agent Deployments

Organizations that require strict compliance, audit trails, and financial controls for any automated spending can deploy Capri AgentPay to meet regulatory requirements. Every transaction produces a verifiable receipt that can be independently verified offline, satisfying audit demands. The human-in-the-loop approval workflow provides a clear separation of duties, while the policy engine enforces spending limits and merchant restrictions. This makes Capri ideal for regulated industries like finance, healthcare, and legal where agent autonomy must be balanced with rigorous oversight.

Does the agent ever hold my private keys?

No. Capri AgentPay is explicitly designed so that agents never hold, access, or manage private keys. The runtime sits between the agent and the signing mechanism. The agent only calls a typed surface, and Capri manages all key operations internally. A signature is only created after the policy engine has evaluated and approved the transaction. This eliminates the primary security risk of autonomous agents: a compromised prompt draining a wallet.

What happens when a transaction exceeds the auto-approve threshold?

When a transaction exceeds the auto-approve threshold, Capri AgentPay pauses the request and enters a human-in-the-loop review state. The operator sees a clear interface displaying the exact amount, asset, chain, and recipient, along with which policy branch triggered the review. The operator can then approve, deny, or modify the request. Once approved, the payment proceeds and the original API call is retried with proof of payment. This ensures that large or unusual transactions always get human oversight.

Can I verify receipts offline without connecting to Capri?

Yes. Every transaction generates a signed receipt that contains hashes, timestamps, chain details, and verification fields. These receipts are designed to be independently verifiable offline using standard cryptographic tools. This means you can store receipts for compliance, auditing, or accounting purposes and verify their authenticity without needing to connect to Capri's infrastructure. The receipts serve as tamper-evident proof that a specific payment was authorized and settled according to policy.

What chains and settlement methods does Capri AgentPay support?

Capri AgentPay currently supports settlement on Base Sepolia for sandbox testing and development. The product is designed to be chain-agnostic and will expand to additional networks based on demand. The x402 payment handling standard is chain-agnostic, meaning the same policy engine and workflow can work across different settlement layers. The sandbox environment allows teams to test their agent payment flows, policy configurations, and receipt verification without risking real funds.