Amazon Bedrock AgentCore Payments Goes GA With MPP and Spending Caps
In this article
Amazon shipped AgentCore Payments into general availability on August 18, 2026, completing a transition from the May preview that first paired the service with Coinbase and Stripe. The GA release adds a second payment protocol, an upto spending scheme, and production-grade observability — turning autonomous agent transactions from a proof-of-concept into deployable infrastructure. For builders stitching together ad-hoc HTTP 402 handlers inside framework execution loops, this matters: payment logic now lives at the infrastructure layer rather than the application layer, which is where the control-surface problems that arise in multi-agent stacks are hardest to audit.
Wallet Architecture and Credential Isolation
AgentCore Payments integrates with two wallet backends: Coinbase and Stripe Privy. Both are stablecoin wallets designed for microtransactions denominated in cents, funded either via credit card or USDC. Delegation flows from end user to agent — the user grants the agent permission to spend on their behalf, but the agent never sees raw credentials. Developer API keys and secrets are stored in the AgentCore Identity Secrets Manager; the service derives short-lived tokens from those credentials and uses them to instruct the wallet provider to sign transactions.
GA adds a Quick Create path for Coinbase available directly in the AgentCore console and CLI, letting developers provision credentials without leaving the platform. Stripe Privy credentials still require a round-trip to the Privy dashboard.
Protocol Support and the "Upto" Scheme
At preview, AgentCore Payments supported only the x402 protocol. GA expands that to include the Machine Payment Protocol (MPP), co-authored by Stripe and Tempo, making the service compatible with MPP-enabled services without requiring additional code. The more architecturally significant addition is the upto scheme within x402. Previously, x402 required merchants to specify an exact price per request, meaning agents committed to a fixed amount before a call completed. The upto scheme lets an agent declare a spending ceiling instead; the merchant charges for actual consumption — LLM tokens, compute units, or any usage-metered resource — at call completion. That unblocks genuine pay-per-inference pricing and any API where per-unit cost varies with workload.
Spending Guardrails and Observability
Because agents are non-deterministic, they can misread a response as authorization to pay or trigger duplicate payments through unexpected retries. AgentCore Payments addresses this through a payment session construct: a scoped context tied to a single agent interaction, carrying two configurable caps — a maximum spend amount in a specified currency, and an expiry time. Before signing any transaction, the service checks the request against the session budget and rejects it deterministically at the infrastructure layer if it would breach the cap. This check runs outside the agent's reasoning loop, so a hallucinated authorization cannot circumvent it. The parallel risk of runaway spending from poorly scoped agent sessions makes infrastructure-layer enforcement, rather than prompt-level instruction, a meaningful architectural distinction.
Observability is handled through integration with AgentCore Observability, which automatically emits vended logs to Amazon CloudWatch and vended spans to AgentCore Observability. Prebuilt dashboards surface transaction success rates and average transaction values, sliced across agents, payment sessions, and time periods.
Framework Integrations and Active Deployments
| Integration | Framework | Mechanism |
|---|---|---|
| Strands Agents plugin | Strands Agents | AgentCorePaymentsPlugin passed at agent construction; handles 402 interception within the plugin lifecycle |
| LangGraph middleware | LangGraph | AgentCorePaymentsMiddleware injected into agent creation; compatible with LangSmith tracing |
| OpenClaw plugin | OpenClaw / ClawHub | agents-pay skill intercepts HTTP 402 at runtime and routes through AgentCore Payments without human intervention |
| AgentCore CLI | Any | Scaffolds credential provisioning and transaction routing end-to-end; described as taking minutes rather than days |
| Coding assistant skill | Claude Code, Kiro, Codex | Provides full payment context to the assistant for scaffolding payment-enabled agents from credential setup to execution |
Three production deployments illustrate the breadth of the use-case surface. Anchor Browser, which processes millions of agent traffic requests daily, uses AgentCore Payments to unlock paywalled web content inside browser-automation workflows. Travel platform Travala integrated it into their Travel MCP server, enabling conversational hotel booking across 2.2 million properties through agents such as Claude. SpreadX's Incarna product routes pay-per-inference calls to BlockRun, a model-routing layer that charges per call over x402, letting agents switch models dynamically without managing individual provider API keys. Cloudflare's Monetization Gateway, which sits in front of a significant share of global web content and MCP servers, is explicitly positioned as a day-one payment destination for AgentCore agents.
The GA launch positions payment as a first-class primitive in the agent stack rather than a bolted-on integration — the same architectural shift underway across the broader agentic tooling ecosystem. Infrastructure-layer spending caps enforced outside the model's reasoning loop, combined with protocol-agnostic orchestration across x402 and MPP, give enterprises a deployable path to autonomous agent transactions with audit trails that hold up under production scrutiny.