This post was co-authored with Kevin Jones from Ampersend (Edge & Node) and Chethan Shriyan from the Amazon Bedrock AgentCore Payments team.
Ampersend and Amazon Bedrock AgentCore Payments are addressing one of the toughest problems in agent AI. How do autonomous agents pay for services without developers having to build bespoke billing integrations, credential management, and payment orchestration from scratch? As more services move to pay-as-you-go models built for machine consumption, agents need a way to programmatically transact on the fly and within managed limits using agent payment protocols such as x402.
In this post, learn how Ampersend built a pay-per-intelligence routing layer on top of Amazon Bedrock AgentCore Payments. AI agents autonomously route tasks to the most effective models, pay per request, and work within your spending budget. We’ll also explain how the 2-hop payment pattern works end-to-end and how you can start implementing your own.
About unpersend
Ampersend (by Edge & Node) is a management platform for agent payments and operations. Ampersend sits between a marketplace of agents and model providers. The company’s services handle payment routing, settlement, and operations. Agent builders can access models through a single integration with no per-provider subscriptions or contract overhead, and no billing relationships that scale with the number of providers.
Mr. Ampersend’s argument is simple and clear. Agents should pay for intelligence programmatically and instantly, without human intervention, in the same way they already call APIs.
Ampersend allows AI agents to autonomously pay for intelligence services across multiple model providers through a single integration point powered by the x402 open protocol and Amazon Bedrock AgentCore Payments.
The Challenge: Autonomous Agent Payment Infrastructure
Agent builders and service providers face complementary aspects of the same infrastructure gap.
For agent builder: The agent must call a paid large-scale language model (LLM), paid data API, or paid content endpoint. You need to build wallet management, handle payment signatures, implement agent payment protocols like x402, manage spending limits, and integrate with each provider’s billing. We will spend several months working on the infrastructure before shipping the agent logic.
For applications like Ampersend: We want to give agents access to multiple model providers through a single payment channel. But for that to happen, the underlying payments infrastructure needs to be secure, auditable, and controlled without having to build wallet management or spending controls yourself.
AgentCore Payments solves both of these aspects. It provides the required managed payments infrastructure for agent systems and provides the ability for individual agents to trade autonomously within managed limits.
How Ampersend built a pay-per-intelligence routing layer using AgentCore Payments
Ampersend has built a Pay-Per-Intelligence routing layer on top of AgentCore Payments. An example usage is:
Agents have the task of summarizing research papers, reviewing smart contracts, and analyzing on-chain data. The agent calls Ampersend to publish a catalog of models organized by functional layer. Agents choose a level that matches the complexity of their task, pay per request through AgentCore Payments, and receive results. Behind the scenes, Ampersend uses the Ampersend SDK to reconcile with upstream model providers.
This creates a two-hop payment routing pattern.
Figure 1: Two-hop payment routing—Agent → Unpersend → Model Provider
How the 2-hop payment flow works
The diagram above shows the end-to-end payments architecture. This flow shows how the key AgentCore Payments components work together:
1. Payment Manager – The application backend creates a payment manager that defines wallet connections and spending policies. This is the governance layer that controls how agents can spend.
2. Payment session – Before the agent starts, the backend opens a payment session with a budget limit (for example, $0.05). The agent can only perform transactions within the limits of this session.
3. Process Payment API – When Ampersend returns HTTP 402 (Payment required), the agent calls ProcessPayment with x402 payment details. AgentCore uses the connected wallet’s credentials to sign USDC certificates without the agent ever touching the private key.
4. Credential Provider (Coinbase CDP) – AgentCore connects to Coinbase Developer Platform as a wallet credential provider. The Coinbase developer platform manages the wallet’s storage and signing infrastructure. The agent assumes a scoped AWS Identity and Access Management (IAM) role (ProcessPaymentRole) that can only call ProcessPayment. The role cannot change budgets or access wallet keys directly.
5.Payment – After signing, proof of payment will be sent back to the agent. The agent retries the original request to Ampersend, attaching the proof. Ampersend validates payments on-chain (base network, USDC) and automatically makes payments to upstream model providers (such as BlockRun) using the Ampersend SDK. Two settlements occur: from the agent to the unpersend and from the unpersend to the model provider.
From the agent’s perspective, one paid request was made. I don’t know or care which provider Ampersend routes you to. Ampersend handles provider selection, second payment, and shipping all transparently.
How AgentCore Payments manages the payment lifecycle
AgentCore Payments handles the entire payment lifecycle, so you don’t need to build Ampersend or an agent builder.
managed wallet – AgentCore connects to your Coinbase CDP or Stripe Privy wallet as your payment connection. There’s no need to build wallet management infrastructure or maintain key management. Once Ampersend has connected your credentials, your funded wallet is ready for trading.
Spending governance – Session-level budgets are applied at the infrastructure layer. The application backend sets limits and the agent processes transactions within the limits. If you exhaust your budget, your next payment will be completely denied. Agents operate autonomously but cannot be overridden within deterministic boundaries.
Native x402 protocol – When the agent encounters a paid endpoint (HTTP 402), AgentCore handles x402 protocol negotiation, wallet authentication, stablecoin payments, and proof delivery without interrupting the agent’s inference loop. Both v1 and v2 of the protocol are supported.
Observability – All transactions flow through the same logs, metrics, and traces that developers already use with AgentCore. There’s no need to build a separate payment monitor.
What is possible with Ampersend and AgentCore Payments?
Neither system can address the full agent commerce stack on its own. Together, they cover end-to-end routing, payments, governance, and observability.
Unpersend brings: Intelligent model routing, provider marketplaces, two-hop payment patterns that abstract away provider complexity, and operational tools for managing agent payment workflows at scale.
What AgentCore Payments brings to you: A security model that provides managed wallet infrastructure, deterministic spending governance, native x402 signing and settlement, and the ability for autonomous agents to transact without exposing credentials or overriding budgets.
Together, they demonstrate what agent commerce is really like. Agents discover, evaluate, select, and pay for intelligence services, all within a managed, observable, and auditable framework.
result
Ampersend completed the full integration within two weeks, from the first API call to end-to-end payment settlement on the Base network. Without AgentCore Payments, the team estimated that wallet storage, signing infrastructure, and spend management alone would require three to four months of engineering effort.
Kevin Jones, who led the integration, said:
“Building a multi-agent system was really complex, and we expected the payment infrastructure to be the most difficult part of the whole project. AWS AgentCore Payments completely changed that. The integration between the buyer agent and AgentCore, the seller agent and Ampersend, and the entire BlockRun AI for pay-as-you-go LLM inference worked together much more smoothly than we expected. Once we wired up the logic, it just clicked.”
Rodrigo Coelho, CEO of Edge & Node:
“We built Unpersend to be a control layer for agent payments, and AgentCore Payments was a natural fit. With managed wallets, spending guardrails, and x402 payments, we can now demonstrate fully autonomous agent-to-agent micropayments in a matter of days.”
conclusion
The Ampersend and AgentCore Payments integration demonstrates what is possible when agent platforms can offload wallet storage, x402 protocol processing, and spend governance to managed infrastructure. Agent builders gain a single payment surface for paid intelligence, and platforms like Ampersend can focus on routing and marketplace logic instead of payment plumbing. The result is autonomous agent-to-agent commerce that is managed, observable, and auditable by default.
Start
Ready to build pay-as-you-go agent workflows? Here’s how to get started.
1. Set up AgentCore payments – Follow the AgentCore CLI quickstart to create a Payment Manager, connect to your wallet provider, and set up your first payment session with spending limits.
2. Integration with Unpersend – Visit ampersend.ai to explore the model catalog and integrate your agent with Ampersend’s payment routing API.
3. Try the tutorial – Explore the hands-on AgentCore Payments workshop and GitHub samples to see buyer/seller implementations in action.
Learn more:
• Amazon Bedrock AgentCore Payments documentation
• Agents to transact with: Amazon Bedrock AgentCore now includes Payments (Preview) – Launch Announcement
• AgentCore Payments samples and workshops on GitHub
• x402 protocol
• Ampersend
About the author
