Amazon Bedrock AgentCore Payments Enables AI Agents to Transact Independently

Amazon Bedrock AgentCore has introduced a new payments capability that allows artificial intelligence agents to autonomously purchase services they need to complete tasks, such as model inferences or API calls. This feature aims to streamline complex workflows by enabling agents to handle micro-transactions, often fractions of a cent, without direct human oversight.

The Chenab Times has learned that this innovation is exemplified by the collaboration between Incarna and BlockRun. Incarna has integrated AgentCore payments to allow its AI agents to pay BlockRun for model inference requests on a per-request basis. BlockRun, an inference router supporting over 90 models from more than 15 providers via the x402 payment protocol, settles each quote and transaction independently. The integration of AgentCore payments with x402-compatible endpoints, including those from Amazon Bedrock, significantly reduced the development time for Incarna, cutting it from months to days and enabling the deployment of a production-ready pay-per-inference system.

The Challenge of Micro-Transactions for AI Agents

Traditionally, AI agents requiring external services to complete tasks faced a significant hurdle in managing high-frequency, low-value payments. Each inference or API call might cost less than a cent, and an agent could make hundreds of such purchases within a single operational session. Existing payment networks are not designed for these sub-cent transactions. Developing custom payment infrastructure to handle these micro-payments presents substantial challenges, including secure money holding, transaction signing, support for emerging protocols like x402, and robust mechanisms to prevent autonomous agents from exceeding predefined spending limits.

AgentCore Payments: A Managed Solution

Amazon Bedrock AgentCore provides a comprehensive platform for building, connecting, and optimizing AI agents at scale. The integrated AgentCore payments capability offers developers a managed solution to embed payment functionalities into their agents with minimal code. It abstracts away the complexities of payment protocols, wallet integration, transaction signing, and spending limit enforcement. Builders can leverage this single managed service instead of piecing together disparate components.

Key features of AgentCore payments that make it suitable for pay-per-inference include:

• Managed Wallets: Incarna utilizes Coinbase CDP connector to provision wallets for each agent. Customers retain ownership of these wallets, granting Incarna delegated authorization for their use.
• Native Protocol Handling: When a paid endpoint responds with an HTTP 402 (Payment Required) status, AgentCore payments facilitates the payment using the x402 protocol. It signs transactions with the configured wallet and provides cryptographic proof to the merchant.
• Infrastructure-Layer Spending Governance: Spending limits are enforced at the infrastructure level, ensuring that agents cannot exceed these boundaries, even if subjected to prompt manipulation.
• Auditable Settlement: Payments are settled using stablecoins, with Incarna opting for USDC on the Base network. Each transaction is verifiable on the blockchain.

The architecture involves AgentCore managing the agent, BlockRun providing metered inference services, and AgentCore payments connecting to the customer’s wallet to enforce spending limits and sign payments on behalf of the agent.

Implementing Pay-Per-Inference

The integration process for AgentCore payments is designed to be accessible. Developers can utilize guided conversations within the Agent Toolkit for AWS or employ the AgentCore CLI, SDK, or AWS SDK for manual setup. The initial steps involve securely storing payment credentials (such as Coinbase CDP or Stripe Privy), creating a Payment Manager with a connector and default spending limit, and then establishing a payment instrument—an embedded wallet that the agent uses for transactions. End-users fund this wallet and grant signing permissions, with test networks available for initial setup using testnet USDC.

Transaction Flow for a Single Inference

In the integrated system, BlockRun acts as the service provider, offering metered model inference from a dynamic catalog where each call is quoted, paid, and settled individually. The process for a single inference is as follows:

1. The AI agent initiates a request for a model call, integrating with BlockRun, which manages provider selection and delivery.
2. BlockRun responds with a Payment Required challenge, including the specific price for the requested inference.
3. A payment session is opened, and the ProcessPayment function is called. AgentCore payments verifies the quote against the session’s spending limits and signs the authorization using the agent’s wallet address.
4. The seller (BlockRun) validates the payment signature.
5. BlockRun then delivers the requested inference, recording the small per-call charge.

This per-request settlement model ensures agents only pay for services they actually consume, with no cost incurred for unmade calls.

AgentCore payments supports two x402 payment schemes: exact, for situations where the price is predetermined, and upto, designed for services with dynamic pricing, where an agent authorizes a maximum spend. In the upto scheme, the inference provider settles based on actual usage, not exceeding the authorized ceiling.

Robust Spend Control Mechanisms

A critical component that instills confidence in deploying agents with real financial capabilities is the payment session. This feature establishes a spending ceiling, the maximum amount an agent can expend, which is rigorously enforced by AgentCore payments at the infrastructure level, independent of the agent’s code or prompt. Each session also has an expiry time. Incarna, for instance, sets daily budgets for its sessions, ensuring that even in the event of agent logic errors, spending remains within the customer-defined limits. This control mechanism can be adopted by existing integrations without requiring code modifications.

Results and Production Deployment

Incarna has successfully deployed its pay-per-inference flow on the Base network, with BlockRun managing the supply side and AgentCore payments overseeing all transactions. Vicky Fu, Founder of BlockRun, stated, “The next generation of AI agents shouldn’t have to choose between better performance and sustainable economics. BlockRun’s open source router gives developers full control over their own model set, while continuously benefiting from BlockRun’s ongoing benchmark-driven routing improvements—delivering higher task success rates at lower token cost. And with AgentCore payments and x402 providing the spending controls agents need, that intelligence can be put to work safely in the real world.”

The Incarna team reported completing the full AgentCore payments integration in just three days: one day for development and two for testing. This involved approximately 200 lines of application code, a stark contrast to the initial two-to-three-month scope. During the beta phase, agents processed over 1,000 payments, with individual call costs ranging from $0.001 to $0.05, each settled on-chain.

Justin Zhou, Founder of Incarna, commented, “AgentCore payments covered everything we needed for an agent to pay over x402: a wallet the customer owns, a funding and revocation flow, a spending limit the platform enforces, and signing that handles both versions of x402. We wrote none of it.”

Conclusion and Getting Started

Amazon Bedrock AgentCore payments offers a governed and on-demand method for AI agents to pay for the services they utilize. The collaboration between BlockRun and Incarna demonstrates a complete end-to-end solution where an agent can pay for inference, a provider can meter and settle these payments, and a distinct identity can own each transaction. For developers building agents that require transactional capabilities during operation, AgentCore payments provides a consolidated and secure integration point.

To begin implementing pay-per-inference, users can follow these steps:

1. Set up AgentCore payments: Establish a Payment Manager, configure wallet connections, and define spending policies. Connect a Coinbase CDP wallet as the credential provider, following the instructions in the AgentCore payments developer guide.
2. Open a payment session: Prior to task execution, initiate a session with a spending cap appropriate for the workload. The agent will operate within this enforced ceiling.
3. Call a paid endpoint: Direct the agent to an x402-compatible service, such as BlockRun. Upon receiving an HTTP 402 response, initiate ProcessPayment with the necessary transaction details. AgentCore payments will manage the signing process and provide proof of payment for service access.

For those interested in exploring the implementation details, AgentCore payments samples are available on GitHub.