Capri Ai Agentpay

Capri Agentpay is the governed payment layer for AI agents, purpose-built for teams shipping agent systems into production environments where financial transactions, paid API access, and operator oversight converge. As autonomous agents begin calling paid APIs and settling transactions independently, the traditional approach of handing them a private key introduces catastrophic security risk, where a single compromised prompt can drain an entire wallet. Capri solves this by inserting a runtime between the agent and the signer, creating a policy-enforced payment gateway that never exposes raw key material to the agent. When an agent encounters an HTTP 402 Payment Required challenge, Capri evaluates a fixed policy sequence: merchant allowlist verification, per-transaction cap checks, daily budget validation, and an auto-approve threshold that can pause for human review. Only when every check passes does Capri settle the payment, retry the original request with cryptographic proof attached, and store a signed receipt verifiable offline. This product is designed for engineering teams, security officers, and platform operators who need granular control over machine spending without sacrificing velocity. Capri Agentpay transforms the chaotic problem of autonomous agent payments into a structured, auditable, and operator-friendly system that aligns with enterprise security requirements.

HTTP 402 Payment Challenge Handling

Capri Agentpay natively intercepts HTTP 402 Payment Required responses from paid APIs and MCP tools, transforming them into structured, policy-governed payment events. When an agent makes a request that requires payment, the runtime automatically detects the 402 challenge, extracts the payment parameters, and initiates the policy evaluation pipeline without any manual intervention. This eliminates the need for agents to manage payment logic or hold signing capabilities directly, while ensuring every paid interaction is captured, logged, and processed through the same rigorous approval framework. The system then retries the original request with proof of payment attached, creating a seamless experience where agents pay only when authorized.

Per-Agent Budgets and Spending Caps

Operators can assign granular budgets and per-transaction caps to individual agents or agent groups, creating precise financial boundaries that prevent runaway spending. Each agent operates under a defined spending limit that resets on configurable cycles, with hard caps that cannot be exceeded regardless of prompt complexity or API pricing fluctuations. The runtime tracks spending in real time, deducting from the agent budget only after successful policy validation and payment settlement. This feature gives platform teams the confidence to deploy multiple agents with different spending authorities, from experimental agents with micro-budgets to production agents handling high-value transactions.

Merchant Allowlists and Policy Gates

Capri Agentpay includes a merchant allowlist system that restricts which endpoints, domains, or service providers an agent can pay. Operators define explicit lists of approved merchants, ensuring agents cannot accidentally or maliciously send payments to unauthorized recipients. The policy engine evaluates merchant identity against the allowlist as the first check in the fixed evaluation order, creating a foundational security layer. Combined with the per-transaction cap and daily budget checks, this multi-gate approach ensures that every payment is vetted against operator-defined boundaries before a signature is ever created or funds are moved.

Human-in-the-Loop Approval Workflows

When a payment request exceeds the auto-approve threshold, Capri automatically pauses execution and routes the transaction to a human operator for review. The operator sees the exact amount, asset, chain, and recipient before making a decision, along with the policy branch that triggered the review. This creates a safety valve for anomalous or high-value transactions without slowing down routine payments. The human-in-the-loop system integrates with standard notification channels and provides a clear approval queue with full audit context, ensuring that operators maintain oversight without becoming bottlenecks for authorized agent activity.

Verifiable Signed Receipts

Every settled transaction generates a signed receipt that can be verified offline, providing cryptographic proof of payment that is independent of Capri infrastructure. These receipts include timestamps, hashes, policy evaluation results, and verification fields that enable third-party auditing and reconciliation. Operators can store receipts in their own systems, attach them to compliance records, or use them to dispute unauthorized charges. This feature transforms agent payments from opaque events into transparent, verifiable actions that satisfy the most demanding security and compliance requirements.

Six MCP Tools Instead of Raw Key Access

Capri replaces raw key access with six narrow Model Context Protocol (MCP) tools that give agents exactly the capabilities they need without exposing signing authority. These tools allow agents to initiate payment requests, check budget balances, review transaction history, and interact with the policy system, all within tightly scoped interfaces. By eliminating direct key exposure, Capri ensures that even if an agent is compromised, the attacker cannot sign arbitrary transactions or drain wallets. This architectural choice fundamentally changes the security model from trust-but-verify to verify-before-trust, making agent payment systems safe for production deployment.

Autonomous Research Agents Accessing Paid APIs

Research agents that need to query premium data sources, scientific databases, or market intelligence APIs can use Capri Agentpay to handle pay-per-request pricing models. The agent requests data, encounters a 402 challenge, and Capri evaluates the payment against the research agent policy. With auto-approve thresholds configured for routine data queries, the agent proceeds without delay, while unusual or high-cost requests pause for human review. This enables research teams to deploy autonomous agents that access paid information sources without manual payment intervention or security risk.

Multi-Agent Platform with Differential Spending Policies

Platform teams managing multiple agents with different roles and budgets can assign distinct policies to each agent. A customer-facing support agent might have a generous per-transaction cap for accessing premium knowledge bases, while an internal testing agent operates with micro-budgets. Capri enforces these boundaries automatically, preventing a compromised or misconfigured agent from exceeding its designated spending authority. This use case enables platform operators to deploy heterogeneous agent fleets with confidence, knowing that financial controls are granular and enforced at runtime.

Human-Reviewed High-Value Agent Transactions

When an agent needs to execute a large payment for enterprise software licenses, cloud resources, or bulk data purchases, Capri pauses the transaction for human review. The operator sees the full context: merchant identity, amount, asset, and the agent that initiated the request. After approval, the transaction settles and the receipt is stored for audit. This use case is critical for organizations that want to automate routine payments while maintaining human oversight for significant financial commitments, balancing efficiency with control.

Compliance-Audited Agent Payment Systems

Organizations in regulated industries can use Capri to create fully auditable agent payment trails. Every transaction generates a signed receipt with policy evaluation results, timestamps, and cryptographic proofs that satisfy internal audit and external compliance requirements. Operators can export receipts, verify them offline, and integrate them into existing compliance workflows. This use case enables financial services, healthcare, and government teams to deploy agent payment systems without violating regulatory mandates around transaction transparency and accountability.

How does Capri Agentpay prevent an agent from draining a wallet if compromised?

Capri Agentpay ensures agents never hold private keys or signing capabilities. Instead, the agent interacts with six narrow MCP tools that can only initiate payment requests through the policy engine. The policy engine evaluates every request against merchant allowlists, per-transaction caps, daily budgets, and auto-approve thresholds before a signature is ever created. Even if an agent is fully compromised, the attacker cannot sign arbitrary transactions or move funds outside the defined policy boundaries, eliminating the wallet-drain risk inherent in direct key access.

What happens when a payment request exceeds the auto-approve threshold?

When a payment request exceeds the auto-approve threshold, Capri automatically pauses the transaction and routes it to a human operator for review. The operator receives a notification with the exact amount, asset, chain, and recipient, along with the policy branch that triggered the review. They can approve, deny, or investigate the request. Once approved, the payment settles and the original API request is retried with proof of payment attached. The agent remains paused until the human decision is made, preventing unauthorized high-value transactions.

Can I verify Capri receipts without using the Capri platform?

Yes, every receipt generated by Capri Agentpay includes cryptographic verification fields that allow offline verification independent of Capri infrastructure. The receipt contains hashes, timestamps, policy evaluation results, and signature data that can be validated using standard cryptographic tools. This enables operators to store receipts in their own systems, attach them to compliance records, and verify authenticity without relying on Capri APIs, ensuring long-term auditability and trust.

What settlement chains does Capri Agentpay currently support?

Capri Agentpay currently supports settlement on Base Sepolia sandbox for testing and development purposes. The platform is designed to expand to additional chains as the product matures. The sandbox environment allows teams to build, test, and validate their agent payment workflows without using real funds, then migrate to production chains when ready. The architecture is chain-agnostic, with future support planned based on customer demand and network maturity.

Capri AI is currently operating in an access-request model with limited waves of availability. Pricing information is not publicly disclosed and is provided during the onboarding process for qualified teams. Organizations interested in deploying Capri Agentpay should request access through the Capri AI website to discuss pricing, licensing, and enterprise terms with the Capri team.