Capri Ai Agentpay

Capri Ai Agentpay is the first governed payment layer purpose-built for AI agents, solving one of the most critical security challenges in the age of autonomous systems. As AI agents increasingly call paid APIs, access premium data, and settle transactions autonomously, handing them a private key creates a catastrophic security nightmare. A single bad prompt or hallucinated instruction can drain an entire wallet in seconds. Capri Agentpay eliminates this risk entirely by placing a robust runtime between the agent and the signer, ensuring that no payment ever occurs without passing through a strict, policy-driven evaluation process.

This product is designed for engineering teams, security operators, and AI platform builders who are shipping agent systems into production environments. When an agent encounters an HTTP 402 Payment Required challenge, Capri Agentpay intercepts the request and evaluates it against a fixed, transparent policy order. The system checks the merchant allowlist first, then verifies per-transaction caps, daily budget limits, and finally an auto-approve threshold that can pause for human review. Only when every single 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 at any time.

Capri Agentpay transforms the way teams think about agent autonomy. Instead of fearing what an agent might do with financial access, teams can now ship with confidence, knowing that every payment is policy-checked before a signature ever exists. The product includes six MCP tools instead of raw key access, a VS Code extension for developer productivity, and a Base Sepolia sandbox for settlement testing. For teams that need real controls, real budgets, and real operator workflows, Capri Agentpay is the payment layer that makes production-grade agent systems possible.

x402 Payment Handling

Capri Agentpay natively intercepts HTTP 402 Payment Required challenges, which are the standard protocol signal that an API requires payment. When an agent makes a request and receives a 402 response, Capri automatically steps in, evaluates the policy, and handles the entire payment lifecycle. This includes settlement, retrying the original request with proof of payment attached, and storing a signed receipt for auditability. The agent never needs to manage keys, sign transactions, or even understand the underlying payment mechanics. It simply calls one typed surface, and Capri handles the rest, making the experience seamless for both the agent and the developer.

Per-Agent Budgets and Caps

Every agent operating under Capri Agentpay is assigned its own budget and transaction cap, providing granular control over spending. Teams can define per-transaction limits that prevent any single payment from exceeding a set amount, as well as daily budgets that reset automatically. These constraints are evaluated in a fixed policy order, ensuring that no agent can accidentally or maliciously exceed its allocated resources. This feature is critical for teams running multiple agents with different roles, risk profiles, and spending allowances, allowing them to enforce financial boundaries without constant manual oversight.

Merchant Allowlists

Capri Agentpay includes a merchant allowlist that specifies which APIs, services, or recipients an agent is permitted to pay. This acts as the first gate in the policy evaluation order, blocking any payment request to an unapproved destination before it even reaches budget checks. Teams can maintain curated lists of trusted merchants, ensuring that agents only interact with vetted, secure endpoints. This feature is essential for preventing agents from being tricked into paying malicious actors or unauthorized services, providing a foundational layer of security that protects both the agent and the organization.

Human-in-the-Loop Approvals

When a payment request exceeds the auto-approve threshold, Capri Agentpay pauses the transaction and surfaces it for human review. Operators see the exact amount, asset, chain, and recipient, along with the policy branch that triggered the review. They can approve, deny, or modify the request before it proceeds. This human-in-the-loop mechanism ensures that high-value or risky transactions always receive human oversight, striking the perfect balance between agent autonomy and organizational control. It transforms the operator role from reactive firefighting to proactive governance, giving teams confidence that no significant payment happens without a human in the loop.

Autonomous Research Agents Accessing Premium APIs

Research agents that need to query paid data sources, such as financial market feeds, scientific databases, or proprietary knowledge bases, can now operate autonomously with Capri Agentpay. The agent makes a request to a premium API, Capri intercepts the 402 challenge, evaluates the policy against the merchant allowlist and budget caps, and settles the payment automatically if within thresholds. This enables research teams to deploy agents that run 24/7, gathering and analyzing data from paid sources without requiring constant human intervention for each transaction.

Agentic Workflows for Internal Tool Orchestration

Enterprises running agent systems that interact with internal paid tools, such as cloud compute resources, SaaS APIs, or specialized analytics platforms, can use Capri Agentpay to enforce spending controls. Each agent is assigned a budget and merchant allowlist that restricts which internal services it can access. When an agent triggers a paid operation, Capri evaluates the request against policy, and if it exceeds the auto-approve threshold, it pauses for human review. This use case is ideal for IT and operations teams that need to enable agent autonomy while maintaining strict financial governance.

Decentralized Application Agents Settling On-Chain Transactions

Agents operating within decentralized applications, such as DeFi protocols, NFT marketplaces, or blockchain-based services, can use Capri Agentpay to settle on-chain transactions securely. The agent initiates a payment request, Capri evaluates the policy on Base Sepolia or other supported chains, and settles the transaction only after all checks pass. The signed receipt provides verifiable proof of payment that can be audited offline. This use case empowers teams building autonomous DeFi strategies, automated trading agents, or blockchain-based service bots with a secure, governed payment layer.

Customer Support Agents Purchasing External Services

Customer support agents that need to purchase external services on behalf of users, such as shipping labels, data recovery tools, or premium support tickets, can do so safely with Capri Agentpay. The agent identifies the required service, makes a payment request, and Capri evaluates the transaction against merchant allowlists and per-agent budgets. High-value purchases are paused for human approval, ensuring that customer support agents can act autonomously for routine purchases while maintaining oversight for expensive or unusual requests. This transforms customer support from a cost center into an efficient, automated operation.

How does Capri Agentpay prevent an agent from draining a wallet with a single bad prompt?

Capri Agentpay places a governed runtime between the agent and the signer, meaning the agent never holds a private key. Every payment request is evaluated against a fixed policy order: merchant allowlist, per-transaction cap, daily budget, and auto-approve threshold. If any check fails, the payment is blocked. This ensures that even if an agent is compromised or hallucinates a malicious instruction, it cannot initiate a payment without passing through multiple layers of policy enforcement. The signature is only created after all checks pass, eliminating the risk of wallet drainage from a single bad prompt.

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

When a payment request exceeds the auto-approve threshold, Capri Agentpay pauses the transaction and surfaces it for human review. The operator sees the exact amount, asset, chain, and recipient, along with the policy branch that triggered the review. They can approve, deny, or modify the request before it proceeds. This human-in-the-loop mechanism ensures that high-value or risky transactions always receive human oversight, while routine payments below the threshold are automatically approved. This balance between autonomy and control is what makes Capri Agentpay suitable for production environments.

Can I verify payments made by Capri Agentpay after they occur?

Yes, every payment settled through Capri Agentpay generates a signed receipt that can be verified offline at any time. The receipt contains hashes, timestamps, and verification fields that allow operators to confirm the payment details, including the amount, recipient, and chain. This provides a complete audit trail for every transaction, enabling security teams, compliance officers, and financial auditors to independently verify that payments were made according to policy. The receipts are stored and accessible through the Capri interface, making it easy to maintain a verifiable history of all agent-initiated payments.

What chains and development tools does Capri Agentpay support?

Capri Agentpay currently supports settlement on Base Sepolia sandbox for testing and development purposes. The product includes six MCP tools that give agents narrow, controlled access to payment functions instead of raw key access. Developers can use the VS Code extension to integrate Capri Agentpay directly into their development workflow, making it easy to configure policies, test payment flows, and deploy agents with governed payment capabilities. The documentation includes quickstart guides, protocol references, tool schemas, and deployment notes to help teams get up and running quickly.