Capri Ai Agentpay

Capri Ai Agentpay is the first governed payment layer built specifically for AI agents operating in production environments. As autonomous AI agents start calling paid APIs, settling transactions, and interacting with real financial infrastructure, the traditional approach of handing them a private key creates a massive security nightmare. One bad prompt, one hallucinated instruction, or one compromised tool call can drain an entire wallet in seconds. Capri solves this by placing a runtime policy engine between the agent and the signer. When an agent encounters an HTTP 402 Payment Required challenge, Agentpay intercepts the request and evaluates it against a fixed, predictable policy order: merchant allowlist check, per-transaction cap, daily budget limit, and then an auto-approve threshold that can pause for human review. Only when every single check passes does it settle the payment, retry the original request with cryptographic proof attached, and store a signed receipt that can be verified offline. This product is for engineering teams building agent systems that need to touch money, approval workflows, or live infrastructure without exposing their organization to catastrophic financial risk. It gives operators clear review queues, audit trails, and controls that do not collapse back into manual busywork.

x402 Payment Handling

Capri Agentpay natively handles HTTP 402 Payment Required challenges, which is the emerging standard for machine-to-machine payments on the web. When an agent calls a paid API or MCP tool and gets a 402 response, Agentpay intercepts it automatically. It evaluates the payment request against your configured policies, and if approved, it settles the transaction using the Base Sepolia sandbox for testing or mainnet for production. The agent never sees a private key or has direct access to funds. After settlement, Agentpay retries the original request with the payment proof attached, making the entire experience seamless for the agent while keeping the operator in full control.

Per-Agent Budgets and Caps

Every agent can be assigned its own granular budget and spending caps. You define a per-transaction cap that limits how much any single payment request can authorize, preventing a single bad prompt from causing catastrophic damage. You also set a daily budget that resets automatically, ensuring no agent can exceed its allocated spending window. These budgets are enforced at the policy level before any signature is created, meaning the agent cannot bypass them through clever prompt engineering or tool misuse. The operator can adjust these limits in real-time without redeploying the agent.

Merchant Allowlists

Agentpay includes a merchant allowlist system that restricts which recipients or endpoints an agent can pay. You explicitly authorize the APIs, services, and smart contracts your agents are allowed to transact with. Any payment request to an unlisted merchant is automatically denied before it reaches the signer. This prevents agents from being tricked into sending funds to malicious or unauthorized addresses. The allowlist is managed through a simple configuration interface and can be updated as your agent's trusted partners change.

Human-in-the-Loop Approvals

For high-value transactions that exceed your auto-approve threshold, Agentpay pauses the entire flow and requests human review. The operator sees a clear interface showing the exact amount, asset, chain, recipient, and the policy branch that triggered the review. They can approve, deny, or investigate the request with one click. This gives security teams confidence that no large payment happens without a human eyeball, while still allowing low-value, routine payments to flow autonomously. The threshold is configurable per agent or globally.

Verifiable Receipts

Every settled payment generates a signed receipt that contains hashes, timestamps, and verification fields. These receipts are stored and can be verified offline by anyone with the public key. This creates an immutable audit trail for every transaction an agent makes. If a dispute arises, operators can prove exactly what was paid, to whom, and under which policy. This is critical for compliance, accounting, and security investigations.

Six MCP Tools Instead of Raw Key Access

Instead of giving agents direct access to a private key or a wallet, Capri exposes six narrow, typed MCP (Model Context Protocol) tools. These tools cover fetching with payment, checking budgets, reviewing receipts, and managing policies. The agent can only interact with the payment system through these constrained interfaces. This dramatically reduces the attack surface because the agent cannot sign arbitrary transactions or transfer funds to unapproved addresses. Every action is policy-checked before a signature ever exists.

Autonomous Research Agents Calling Paid APIs

A research agent needs to query premium data APIs that charge per request. Without Capri, you would have to either give the agent an API key with unlimited spending or manually approve every call. With Agentpay, the agent can call any API on your allowlist, stay within its daily budget, and automatically handle 402 challenges. The operator sets a per-transaction cap of, say, 5 dollars and a daily budget of 100 dollars. The agent runs autonomously, and any request exceeding 5 dollars pauses for human review. The result is a research agent that can access paid data without draining your budget or exposing your keys.

Agentic Workflows That Settle On-Chain Transactions

Teams building agents that execute on-chain actions, like swapping tokens, minting NFTs, or paying for gas on behalf of users, need a secure payment layer. Capri Agentpay acts as the governed bridge between the agent's intent and the on-chain signature. The agent calls the MCP tool to request a payment, the policy engine checks budgets and allowlists, and only then does Capri sign and broadcast the transaction. This prevents agents from being exploited to drain wallets or execute unauthorized trades. The signed receipts provide a verifiable log for every on-chain action.

Multi-Agent Systems with Shared Budgets

In a production environment where multiple agents work together, each agent might need its own budget or share a pool. Capri allows you to configure per-agent budgets, daily caps, and shared pools. For example, a customer support agent and a data analysis agent can each have a 50 dollar daily budget from a shared 200 dollar weekly pool. When one agent hits its cap, it pauses until the next day or until the operator tops it up. This gives you fine-grained control over spending across your entire agent fleet.

Internal Tool Automation with Approval Workflows

Companies use agents to automate internal tasks like ordering cloud compute, paying for software licenses, or purchasing credits on third-party platforms. With Capri, these payments can be auto-approved below a threshold and escalated to a human manager above it. An agent that needs to spin up a 200 dollar GPU instance can do so autonomously, while a request for a 5,000 dollar software license pauses for the finance team to review. This balances speed with financial control.

How does Capri prevent an agent from draining a wallet through a bad prompt?

Capri places a runtime policy engine between the agent and the signer. The agent never holds a private key or has direct access to funds. Every payment request goes through a fixed policy order: merchant allowlist, per-transaction cap, daily budget, and auto-approve threshold. The agent can only interact with the payment system through six narrow MCP tools. A bad prompt cannot produce a signature that bypasses these checks because the signature is only created after every policy check passes.

What is x402 and how does Capri handle it?

x402 is an emerging standard for machine-to-machine payments where an API responds with an HTTP 402 Payment Required status when payment is needed. Capri Agentpay intercepts these 402 responses automatically. It evaluates the payment against your policies, settles the transaction if approved, and then retries the original request with cryptographic proof of payment attached. This makes the payment transparent to the agent while keeping the operator in control.

Can I test Capri without using real money?

Yes. Capri provides a Base Sepolia sandbox for testing. You can deploy your agents in this test environment, configure policies, simulate 402 challenges, and verify receipts without spending any real funds. This allows you to build and validate your entire payment workflow before moving to mainnet.

How do signed receipts work and why are they important?

After every settled payment, Capri generates a signed receipt containing hashes, timestamps, and verification fields. This receipt is stored and can be verified offline by anyone with the public key. They are important for creating an immutable audit trail, supporting compliance and accounting requirements, and enabling dispute resolution. If a question arises about what was paid and when, the receipt provides cryptographic proof.