Capri Ai Agentpay

Capri AgentPay is the governed payment layer for AI agents that need to settle transactions, call paid APIs, and interact with financial infrastructure without exposing private keys or creating security liabilities. As autonomous agents increasingly operate outside the safety of controlled prompts, the risk of a single bad instruction draining a wallet becomes a critical operational concern. Capri solves this by placing a runtime policy engine between the agent and the signing mechanism, ensuring every payment request is evaluated against a fixed, transparent set of rules before any signature is generated.

When an agent issues a fetch request and encounters an HTTP 402 Payment Required challenge, Capri intercepts the call and runs it through a predefined policy pipeline. The pipeline checks, in order: whether the merchant is on an allowlist, whether the transaction stays within a per-transaction cap, whether the daily budget is not exceeded, and finally whether the amount falls below an auto-approve threshold. If the amount exceeds that threshold, the request pauses for human review. Only when all checks pass does Capri settle the payment, retry the original request with a cryptographic proof attached, and store a signed receipt that can be verified offline at any time.

Capri AgentPay is designed for engineering teams shipping agent systems in production, particularly those working with paid APIs, on-chain settlements, or approval workflows. It replaces raw key access with six narrow MCP tools, a VS Code extension for developer workflow integration, and a Base Sepolia sandbox for testing. Agents never hold keys, and every payment is policy-checked before a signature ever exists. The result is a system where operators retain full control, audit trails are immutable, and agents can safely interact with real financial infrastructure.

x402 Payment Handling

Capri AgentPay natively handles HTTP 402 Payment Required challenges, a protocol-level signal that a resource requires payment. When an agent encounters a 402 response, Capri intercepts the request, evaluates the payment against the configured policy, and if approved, settles the transaction and retries the original call with proof of payment attached. This eliminates the need for agents to manage payment logic or hold credentials.

Per-Agent Budgets and Caps

Operators can define granular spending limits per agent, including per-transaction caps and daily budgets. These limits are enforced at runtime by the policy engine, ensuring no single agent can exceed its allocated resources. This feature is critical for teams running multiple agents with different roles, access levels, and spending authority.

Merchant Allowlists

Capri allows operators to maintain a curated list of approved merchants or API endpoints that an agent is permitted to pay. Any request to a merchant not on the allowlist is automatically denied, preventing agents from sending funds to unknown or malicious destinations. This provides a simple, enforceable boundary around agent financial activity.

Human-in-the-Loop Approvals

When a payment request exceeds the auto-approve threshold, Capri pauses the transaction and surfaces it in a human review queue. Operators see the exact amount, asset, chain, and recipient before deciding to approve or deny. This ensures that high-value or unusual transactions always get human oversight without blocking routine, low-value payments.

Verifiable Receipts

Every settled transaction generates a signed receipt containing hashes, timestamps, and verification fields. These receipts can be stored and verified offline, providing an immutable audit trail for compliance, accounting, or security reviews. Operators can independently confirm that a payment was authorized and processed correctly.

Six MCP Tools Instead of Raw Key Access

Capri replaces direct key access with a set of six narrow Model Context Protocol (MCP) tools that agents can call. These tools cover payment initiation, policy checks, receipt retrieval, and budget queries. By limiting the agent to these tools, Capri eliminates the risk of a compromised agent signing arbitrary transactions.

Autonomous Data Retrieval from Paid APIs

Teams building research agents or data pipelines often need to call premium APIs that charge per request. With Capri, an agent can autonomously fetch data from paid endpoints while operators control budgets and approve unexpected costs. The agent never sees the API key, and every charge is logged with a verifiable receipt.

On-Chain Settlement for Agent Services

Agents that provide services to other agents or humans, such as compute, storage, or data access, can settle payments on-chain using Capri. The governed payment layer ensures that settlements only occur within policy boundaries, preventing runaway costs or unauthorized transfers. Receipts provide on-chain and off-chain audit trails.

Internal Tooling and Infrastructure Payments

Enterprise teams running agent systems that interact with internal paid tools, such as cloud APIs, database services, or analytics platforms, can use Capri to control spending. Per-agent budgets and merchant allowlists ensure that agents only access approved internal services and stay within allocated spend limits.

Multi-Agent Workflows with Shared Budgets

In production environments where multiple agents collaborate on a task, Capri enables shared budgets with individual caps. A lead agent can coordinate payments across sub-agents, while the policy engine enforces overall spending limits. Human review thresholds catch anomalous requests from any agent in the workflow.

How does Capri AgentPay prevent an agent from draining a wallet?

Capri places a runtime policy engine between the agent and the signing mechanism. The agent never holds a private key. Every payment request is evaluated against a fixed policy pipeline: merchant allowlist, per-transaction cap, daily budget, and auto-approve threshold. Only when all checks pass is a signature generated. A single bad prompt cannot result in an unauthorized transaction because the policy engine blocks it before any signing occurs.

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

When a request exceeds the auto-approve threshold, Capri pauses the transaction and places it in a human review queue. 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. The agent waits until a decision is made, ensuring high-value transactions always have human oversight.

Can I verify a receipt offline after a payment is settled?

Yes. Every settled transaction generates a signed receipt containing hashes, timestamps, and verification fields. These receipts are stored by Capri and can be exported for offline verification. Operators can independently confirm that a payment was authorized by the policy engine and processed correctly, making the receipts suitable for compliance, accounting, and security audits.

What chains and assets does Capri AgentPay support for settlement?

Capri AgentPay currently supports settlement on Base Sepolia for sandbox testing and testing with testnet assets. The system is designed to be chain-agnostic and supports multiple assets. The policy engine evaluates the asset and chain as part of its checks, allowing operators to restrict settlement to specific chains or tokens per agent or policy.