Capri Ai Agentpay

Capri Agentpay is the governed payment layer for AI agents, built for teams that need real controls the moment an agent touches money, approval workflows, or live infrastructure. As autonomous agents start calling paid APIs and settling transactions on their own, handing them a private key becomes a security nightmare. One bad prompt can drain a wallet in seconds. Capri solves this by putting a runtime between the agent and the signer, ensuring no payment happens without policy checks.

The product intercepts HTTP 402 Payment Required challenges automatically. When an agent hits a paid endpoint, Capri evaluates your policy in a fixed order: merchant allowlist, per-transaction cap, daily budget, and an auto-approve threshold that can pause for human review. Only when every check passes does it settle the payment, retry the original request with cryptographic proof attached, and store a signed receipt you can verify offline. Agents never hold your keys. Every payment is policy-checked before a signature ever exists.

Capri Agentpay is for engineering teams shipping agent systems in production, security teams that need audit trails and verifiable receipts, and operators who want clear review queues without manual busywork. It ships with six MCP tools instead of raw key access, a VS Code extension for developer workflows, and Base Sepolia sandbox settlement for testing. The result is fast, efficient, and secure machine payments that let you ship agents to production without fear.

x402 Payment Handling

Capri Agentpay automatically intercepts HTTP 402 Payment Required challenges from paid APIs and MCP tools. When an agent makes a request and hits a 402, the runtime pauses, evaluates your policy, and only settles the payment if every check passes. It then retries the original request with proof attached. This eliminates the need for agents to manage keys or manually handle payment prompts. The entire flow is fast, automated, and secure, letting agents call paid endpoints without exposing your wallet to a single bad prompt.

Per-Agent Budgets and Caps

You can set granular budgets and transaction caps for every individual agent. Define a per-transaction maximum and a daily budget that resets automatically. When an agent tries to spend beyond its cap, Capri blocks the payment instantly. This gives you fine-grained control over spending without micromanaging every request. You can scale to dozens or hundreds of agents, each with its own limits, and know that no single agent can drain your funds. It is speed and efficiency for financial controls at scale.

Merchant Allowlists

Capri lets you define explicit allowlists of trusted merchants or API endpoints that agents are permitted to pay. Any request to a merchant not on the list is automatically denied before a signature is ever generated. This prevents agents from accidentally or maliciously sending payments to unknown or unauthorized recipients. You build the allowlist once, and every agent respects it. It is a simple, fast security boundary that eliminates entire classes of risk without slowing down your development velocity.

Human-in-the-Loop Approvals

When a payment request exceeds your auto-approve threshold, Capri pauses the transaction and sends it to a human operator for review. The operator sees the exact amount, asset, chain, and recipient before approving or denying. This gives you a safety net for high-value or suspicious transactions without blocking routine low-cost API calls. The review queue is clean, fast, and integrated into your workflow. You get the speed of automation with the confidence of human oversight exactly when it matters.

Autonomous Research Agents Using Paid APIs

Research agents that query premium data sources, scientific databases, or paid news APIs need a secure way to settle payments. Capri Agentpay intercepts the 402 challenge, checks the merchant against your allowlist, verifies the daily budget, and auto-approves small transactions. For large or unexpected charges, it pauses for human review. The agent gets the data it needs without holding a private key. Your security team gets signed receipts and a full audit trail. This lets you ship research agents to production in days, not months.

AI Trading and Financial Automation Agents

Trading agents that interact with on-chain protocols, DEXs, or fee-based data feeds require fast, policy-gated payments. Capri Agentpay enforces per-transaction caps and daily budgets, preventing a single bad prompt from draining a trading wallet. The runtime checks every payment against your rules before a signature exists. Human operators review only the largest or most unusual trades. Verifiable receipts allow post-trade auditing. This gives you the speed of automated trading with the security controls your compliance team demands.

Internal Tooling and Infrastructure Agents

Agents that spin up cloud resources, call internal paid services, or manage SaaS subscriptions need payment boundaries. Capri Agentpay lets you define merchant allowlists for your internal APIs and third-party tools. Budgets and caps prevent runaway spending during development or testing. The human-in-the-loop approval catches unexpected charges before they hit your bill. Signed receipts provide a clear record for finance and operations. You get governed automation that your whole organization can trust.

Multi-Agent Orchestration Systems

When you run dozens of agents in parallel, each calling different paid endpoints, managing keys and budgets manually is impossible. Capri Agentpay gives each agent its own policy: unique budgets, caps, and allowlists. The runtime handles 402 challenges for all agents simultaneously, evaluating policies in milliseconds. Operators get a single review queue for threshold-crossing payments across the entire fleet. This lets you scale agent systems without scaling your security risk. It is fast, efficient, and built for production.

How does Capri Agentpay handle agent keys?

Capri Agentpay ensures agents never hold your private keys. The runtime sits between the agent and the signer. When an agent makes a payment request, the runtime evaluates your policy first. Only after every check passes does it generate a signature. This eliminates the risk of a bad prompt or compromised agent draining your wallet. Your keys remain under your control at all times.

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

When a payment request exceeds your configured auto-approve threshold, Capri pauses the transaction and sends it to a human operator for review. The operator sees the exact amount, asset, chain, and recipient. They can approve, deny, or investigate further. Once approved, the payment settles and the original request retries automatically. This gives you a safety net without blocking routine low-cost transactions.

Can I verify receipts offline after a payment is settled?

Yes. Every settled payment generates a signed receipt that you can verify offline. The receipt contains hashes, timestamps, and verification fields that prove the transaction was policy-checked and approved. You can store these receipts in your own audit system and verify them without needing to contact Capri. This is critical for compliance, security audits, and financial reconciliation.

What chains and settlement options are supported?

Capri Agentpay currently supports Base Sepolia for sandbox settlement, allowing you to test payment flows in a safe environment before going to mainnet. The architecture is designed to support additional chains and assets as the product evolves. The x402 protocol handling is chain-agnostic, meaning the same policy engine works regardless of the underlying settlement network.