Cross-chain agent payments are stablecoin transfers initiated by an autonomous AI agent on one blockchain that settle on another, completed without the agent custodying funds, holding wrapped tokens, or writing bridge logic. The pattern is not a niche. Stablecoin supply has fragmented across more than fifteen chains, with USDT at $189.5B and USDC at $77.3B (per DeFiLlama, Apr 2026), and the chains those tokens live on are not the chains where most agent counterparties settle. An agent that pays a Solana-based API in USDC drawn from a Base treasury, or a Tron merchant settling in Ethereum-issued USDT, is doing cross-chain work whether the user notices or not. This guide covers the four settlement patterns (bridge-then-pay, native multi-chain stablecoin, atomic intent-based settlement, multi-chain orchestration), the live deployments, and the tradeoffs that decide which pattern fits which workload. Read the agentic commerce pillar first if the broader category is new, then the stablecoin agent payments primer for the single-chain version of this stack.
​

Cross-chain agent payments are stablecoin transfers an autonomous agent initiates on one blockchain and settles on another, without custodying funds, holding wrapped tokens, or writing bridge logic. The agent picks the destination chain implied by the counterparty, sources liquidity from wherever it sits, and triggers a transfer that lands as spendable balance on the destination.
​

A cross-chain agent payment moves value from a source chain to a destination chain because the buyer (or the agent acting for the buyer) holds liquidity in one place and the seller accepts settlement in another. The agent reads a goal — "pay this invoice," "subscribe to this API," "settle this micro-purchase" — selects a destination chain implied by the counterparty, sources stablecoin liquidity wherever it sits, and triggers a transfer that lands as spendable balance on the destination. The technical work between source and destination is the cross-chain layer. The agent treats it as a single payment.
​

Stablecoin distribution is the reason this matters. Live data on Apr 29, 2026 shows Ethereum holding $45.0B in TVL, BSC $5.5B, Solana $5.4B, Tron $5.0B, Base $4.3B, Arbitrum $1.7B, Polygon $1.3B, Avalanche $637M, and Plasma $599M (per DeFiLlama). Stablecoin supply by issuer footprint follows similar fragmentation: USDT dominates Tron and Ethereum; native USDC ships on roughly fifteen chains via Circle Mint; PYUSD launched on Solana in 2024 then expanded; PayPal's $3.4B PYUSD float and Sky Dollar's $7.8B USDS sit on Ethereum-aligned chains. No single chain holds the canonical liquidity an agent needs.
​

Every agent transacting at any meaningful scale eventually pays a counterparty on a chain it does not hold balance on. That is not an edge case. It is the median case. The 69,000 active agents, 165 million transactions, and roughly $50M cumulative x402 volume tracked by Insignia VC's April 2026 analysis already span EVM and Solana out of the box; multi-chain rollouts at Stripe Sessions 2026 add more. The cross-chain layer is not an optional add-on. It is the surface area that decides whether an agent payment completes or stalls.
​

Every cross-chain agent payment cycles through four operations: identify the counterparty's destination chain and accepted token, source liquidity from the agent's available balances, orchestrate the transfer through one of four settlement patterns, and confirm finality on both sides. Each operation has its own failure modes, latency profile, and trust assumption.
​

Every cross-chain agent payment runs through four operations regardless of the underlying rail: identify the counterparty's destination chain, source liquidity on the agent's home chain, orchestrate the transfer through one of the four settlement patterns, and confirm finality. Each step has different failure modes and different latency profiles.
​

Identify. The agent needs the counterparty's chain plus accepted token list. On x402-style flows, the server returns an HTTP 402 with a payment-required header listing the chain identifier (CAIP-2), the token contract, the amount, and the recipient address (per the Coinbase x402 docs). On non-x402 flows, the agent reads merchant capability via Google's UCP profile or a published payment endpoint. The x402 protocol explainer covers the request/response loop in detail.
​

Source. The agent picks which of its balances funds the payment. A treasury agent might hold USDC on Base, USDT on Tron, and PYUSD on Ethereum simultaneously. The choice depends on which stablecoin maps cleanest to the destination chain and which combination minimizes total cost.
​

Orchestrate. This is the rail-selection step. The agent (or its orchestration layer) picks one of the four patterns described below: bridge-then-pay, native burn-and-mint via Circle CCTP V2, atomic intent-based settlement, or a routing layer that picks among them. Each pattern has different latency and finality characteristics.
​

Confirm. The destination chain confirms the transfer; the source chain releases or burns the corresponding balance. Finality on Base or Optimism is roughly two seconds for soft confirmation, plus the seven-day fault-proof window for hard finality on canonical bridges. Solana finality lands in under a second. CCTP V2's "fast transfer" path completes in seconds end to end. Each rail commits at different points.
​

The mechanism only works when each step composes with the next. An agent that signs an EIP-3009 payload on Base for a Solana destination payment has chosen a settlement pattern, a route, and a finality threshold the moment it signs. The orchestration layer is what selects all three.
​

Cross-chain agent settlement collapses into four mechanically distinct patterns: bridge-then-pay (lock and mint a wrapped token), native burn-and-mint (the issuer mints the same token natively on the destination), atomic intent-based settlement (a solver front-pays the destination), and multi-chain orchestration (a routing layer picks among the prior three per payment). Each is shipping in production today.
​

Cross-chain stablecoin movement collapses into four mechanically distinct patterns. Each is shipping in production. Each fits different agent payment workloads.
​

The traditional pattern. A canonical or third-party bridge locks the token on the source chain; a wrapped representation mints on the destination chain. The agent pays from the wrapped balance, which the merchant either accepts directly or unwraps before redemption. Hyperlane warp routes are the permissionless instance: any team can deploy a warp route that connects any two chains running Hyperlane mailboxes, with collateral, synthetic, or native variants. Hyperlane is a live partner-rail in Eco's stack.
​

LayerZero's Omnichain Fungible Token (OFT) standard takes a different shape: the issuer mints natively on every supported chain and burns on the source when transferring, using LayerZero's verifier-and-executor model for messaging. Tether's USDT0 ships as an OFT for alt-EVM destinations. Wormhole's Native Token Transfers (NTT) covers similar territory through the Wormhole guardian set.
​

The tradeoff with bridge-then-pay is custody. The wrapped token is only as solvent as the bridge contract's locked collateral or the issuer's mint authority. Hyperlane warp routes are non-custodial in the sense that the deployer holds the keys, not a centralized custodian, but the security still reduces to the route's collateral and message-verification model. Latency runs from seconds to a few minutes depending on source-chain finality assumptions.
​

Circle's CCTP V2 is the canonical implementation. USDC burns on the source chain through a CCTP message; an attestation from Circle's off-chain attestation service authorizes the destination chain's CCTP contract to mint fresh native USDC at parity. There is no wrapped representation. Both sides hold the same token, redeemable at the issuer. CCTP V2 added "Hooks" — post-mint callbacks the agent encodes alongside the burn — so a single signed payment can mint on the destination and trigger a downstream action (deposit, swap, forward) in the same flow.
​

For agent payments, the attractive property is composability. An agent paying a Solana merchant from a Base USDC balance signs one CCTP V2 transfer with a Hooks payload that mints USDC into the merchant's Solana address. No wrapped token, no separate redemption step. Stripe's x402 integration on Base uses USDC as the launch pair; Sessions 2026 announcements around multi-chain rollout extend that footprint. CCTP V2's fast-transfer path completes in seconds end to end, fast enough for sub-second-latency-tolerant agent workflows but not for true micropayments.
​

The constraint is the token. Native CCTP supports USDC only. Agents that pay in USDT, PYUSD, RLUSD, or other non-Circle stablecoins need a different rail. Native multi-chain footprints exist for USDT (Tron + Ethereum dominant), USDC (CCTP across roughly fifteen chains via Circle Mint), and PYUSD (Solana + Ethereum via PayPal's mint authority).
​

Intent-based settlement separates "what the agent wants" from "how it gets done." The agent emits a signed intent ("pay 100 USDC on Base, deliver 100 USDT on Solana to address X by block timestamp T"). A solver — a market-maker that has prepositioned inventory on both chains — front-pays the destination side immediately, then claims reimbursement from the source contract once the source-chain commitment finalizes. From the user's perspective, the payment is atomic: either the destination delivery completes and the source funds release, or both states unwind.
​

Several orchestrators run intent-style auctions. Across publishes intents to a relayer network; relayers compete on cost and speed; the protocol settles via a canonical bridge after the fact. Eco Routes uses a similar model with a CLI and API for the agent to submit intents and a solver pool that competes on execution. Peer orchestrators including Relay and LI.FI sit in adjacent territory; their architectures vary, but the agent-facing primitive is similar: intent in, settlement out, with the cross-chain mechanism abstracted. The category-level survey is in intent-based protocols.
​

The properties that matter for agent workloads are user-side latency and atomic finality. Solver-front-paid intents complete on the destination chain in seconds because the solver's inventory is already there; the slow part (canonical bridge settlement) happens out of the user's path. Atomicity matters because an agent doing micropayments cannot afford partial states or stuck mid-flight transfers across counterparty chains. Intent-based settlement is also the cleanest fit for cross-stablecoin pairs (paying USDC and delivering USDT, for example), since the solver does the swap inline.
​

The fourth pattern is meta. An orchestration layer evaluates available rails — CCTP V2, Hyperlane warp route, intent-solver auction, native canonical bridge — and selects whichever fits the cost, speed, finality, and token requirements of the specific payment. The agent submits one intent; the orchestrator decides which of the prior three patterns to execute. The same orchestration thesis underpins stablecoin liquidity networking.
​

Production cross-chain agent payment systems are converging on this shape. Reasoning: no single rail dominates across all dimensions. CCTP V2 is fastest for native USDC but only supports USDC. Hyperlane warp routes work across any token but require collateral solvency assumptions. Intent-based settlement is fastest end to end for cross-token pairs but requires solver inventory. Routing across them gives an agent payment system the latency of intent-based when solver inventory is available, the cost profile of CCTP when it's not, and the token coverage of warp routes for the long tail. Eco operates as the stablecoin orchestration network across 15 chains, with Routes (CLI + API) as the agent-facing surface and rail selection happening per-payment under the hood. Comparable orchestrators (Relay, LI.FI, Squid) implement parts of the same problem with different rail mixes.
​

Five deployments run cross-chain agent payments at non-trivial scale in 2026: Coinbase Agent.market with x402, Stripe's x402 multi-chain rollout, Visa's stablecoin settlement program across nine chains, StraitsX XSGD and XUSD on Solana, and Visa Intelligent Commerce. Each settles on multiple chains by design, even when the user-facing surface hides it.
​

Five deployments are running cross-chain agent payments at non-trivial scale in 2026. Each tells a different part of the picture.
​

Coinbase Agent.market and x402. Coinbase launched Agent.market in April 2026 as an app store for autonomous agents. Agents discover each other and pay each other in stablecoins via x402. The protocol covers EVM chains plus Solana out of the box, per the Coinbase x402 docs. The mechanism: server returns HTTP 402 with a chain selector (CAIP-2) and a token contract; agent signs an EIP-3009 transferWithAuthorization payload scoped to the destination chain; a facilitator verifies and broadcasts on the right chain. Insignia VC tracked roughly 69,000 active agents and 165 million transactions cumulatively by late April 2026, averaging under 30 cents per call.
​

Stripe x402 multi-chain rollout. Stripe added x402 support in February 2026 with USDC on Base as the launch pair (per The Block). At Sessions 2026 (Apr 29-30, with 9,000 attendees and 288 product launches), Stripe and Tempo extended the agent-payment surface through the Machine Payments Protocol (MPP) and added chains to the supported list. The trajectory matters: Stripe picked Base first because Base concentrates the largest agent-developer footprint, but the same flow extends to Solana, Optimism, Arbitrum, and others as MPP rolls out.
​

Visa stablecoin settlement on 9 blockchains. Visa's stablecoin settlement program reached a $7B run-rate and expanded to nine supported blockchains by Q2 2026, up from four (per The Block, April 2026). The program lets Visa-network issuers and acquirers settle in USDC and other stablecoins across the supported chains, with Visa's treasury handling cross-chain mechanics. The implementation is institutional rather than agent-native, but the architecture (multi-chain stablecoin settlement, abstracted cross-chain mechanics) is the same one agent payment systems are converging on.
​

StraitsX XSGD and XUSD on Solana with x402. The Singapore-issued stablecoin pair XSGD and XUSD was announced for Solana with native x402 support on December 16, 2025, with rollout targeted for early 2026 (per StraitsX official blog and Insignia VC's April 2026 analysis). The deployment connects Solana-native agents to Singapore-bank-rail off-ramps without the agent stack needing to know the bridging logic. Card volume on the StraitsX rails grew roughly 40x quarter-over-quarter from Q4 2024 to Q4 2025.
​

Visa Intelligent Commerce and the Agentic Ready Program. Visa's Intelligent Commerce initiative includes pilots with Skyfire, Nekuda, PayOS, and Ramp. The Agentic Ready Program rolled to banks across Europe, the UK, Asia Pacific, and Latin America. The cross-chain dimension here is implicit: as agents settle in stablecoins across the 9-chain Visa stablecoin program, Intelligent Commerce becomes the wrapper that orchestrates the rail selection. Cross-chain OTC execution faces a structurally similar fragmentation.
​

None of these deployments are pure single-chain. All five settle on multiple chains by design. The cross-chain layer is shipping in production, even when the user-facing surface hides it.
​

The four cross-chain settlement patterns differ across five attributes that decide which fits which workload: end-to-end latency, finality model, custody risk, gas overhead, and composability. Latency dominates for micropayments; custody risk dominates for treasury flows; gas overhead matters in batched workloads; composability decides whether downstream actions chain in atomically.
​

The four patterns differ across five attributes that decide which fits which workload. The table below summarizes. For deeper context on the full cross-chain messaging protocols landscape, the messaging-layer comparison is the closest reference.

Latency dominates for micropayment-style workloads (per-API-call billing, sub-cent agent-to-agent transfers). The 165M-transaction x402 footprint is precisely this regime: payments small enough that even a few seconds of bridge latency would dominate the cost. Native burn-and-mint and intent-based settlement both clear that bar; bridge-then-pay sometimes does, depending on the route.
​

Custody risk dominates for institutional and B2B agent payments. A treasury agent moving six- or seven-figure stablecoin balances cannot accept counterparty risk on a wrapped representation. CCTP V2 reduces custody to issuer trust (no wrapped tokens, no bridge collateral); intent-based settlement reduces it to escrow-contract correctness. Bridge-then-pay carries the deepest custody surface area.
​

Gas overhead matters in cost-sensitive batched workflows. CCTP V2's burn + attestation + mint sequence costs less than most three-step bridge flows. Intent-based settlement compresses to one source signature and one destination delivery — cheap because the solver's destination-side balance is already there. Orchestration adds a routing decision but recoups it by picking the cheapest rail per payment.
​

Composability is where CCTP V2 with Hooks and intent-based settlement extend furthest. Hooks let an agent attach a post-mint action atomically (auto-deposit into a yield contract, swap into a different stablecoin, forward to a recipient). Intents support cross-token pairs natively because the solver does the swap inline. Bridge-then-pay yields a wrapped token that the agent or merchant has to explicitly unwrap before downstream use.
​

Pattern choice depends on the token, the chain pair, and the latency tolerance. Native burn-and-mint fits single-token, USDC-only flows. Atomic intent-based settlement fits cross-token pairs where a solver does the inline swap. Bridge-then-pay covers long-tail tokens and chains. Multi-chain orchestration fits production agent systems with diverse counterparties.
​

The choice is not abstract. A few rules of thumb derived from production deployments:
​

Single-token, USDC-only, latency-sensitive flows: native burn-and-mint. CCTP V2 is the cleanest. The Stripe x402 + USDC + Base stack is exactly this case. Hooks extend it to one-shot payments with downstream composition, eliminating the need for a separate settlement leg.
​

Cross-token pairs (USDC ↔ USDT, USDC ↔ PYUSD, fiat ↔ stable): atomic intent-based settlement. The solver does the swap inline, so the agent does not stitch together a CCTP transfer plus a DEX swap plus a deposit. Eco Routes, Across, and Relay all implement this pattern; the differences are solver depth, supported chains, and pricing model.
​

Long-tail tokens or chains where CCTP and OFTs do not reach: bridge-then-pay. Hyperlane warp routes are the permissionless option. Any team can deploy a route between any two Hyperlane-enabled chains. The custody profile is route-specific.
​

Production agent payment systems with diverse counterparties: multi-chain orchestration. The reason is unavoidable: production agents face all three of the prior cases simultaneously, often within the same agent session. A meta-routing layer that picks per-payment is the only durable answer. This is the layer that cross-chain stablecoin swap infrastructure and intent settlement layers sit at, and it's where Eco's product strategy concentrates.
​

Cross-chain orchestration becomes load-bearing because no single rail covers every token, chain pair, and latency profile an agent will encounter. Stablecoin liquidity, agent counterparties, and merchant settlement preferences each fragment differently. An agent locked to one rail eventually meets a payment that rail cannot clear, and the orchestration layer is what absorbs the fragmentation.
​

Every agent payment system that ships at scale eventually integrates more than one rail. The reason is structural: stablecoin liquidity, agent counterparties, and merchant settlement preferences each fragment differently across the chain landscape. An agent that integrates only CCTP cannot pay a merchant whose treasury sits on a non-CCTP chain. An agent that integrates only one bridge cannot route around a route's downtime. An agent that integrates only one intent solver inherits that solver's inventory limits.
​

Three forces compound the fragmentation. Stablecoin issuers ship on more chains over time; cross-chain liquidity deepens unevenly across chains, leaving some hop combinations cheap and others expensive. Agent counterparties (other agents, APIs, merchants) settle on whichever chain serves their workflow best; that decision is local to the counterparty, not the paying agent. And new chains keep launching: HyperEVM, Plasma, Unichain, Ink, and Sonic all gained meaningful agent-relevant footprints in 2026 (per the Eco supported-chain list).
​

Orchestration absorbs this fragmentation. The agent submits one signed intent; the orchestrator picks among CCTP, Hyperlane, intent solver, or canonical bridge based on which rail clears the payment with the lowest cost and acceptable latency. Solver inventory rebalances across chains automatically. Failed routes retry through alternate rails. The agent never writes that logic itself.
​

The pattern parallels how internet routing evolved: applications stopped specifying paths and started specifying destinations. BGP picks the route. The application sees the connection. Cross-chain agent payments are following the same arc — agents specify the destination payment, and the orchestration layer decides the path.
​

Sources and methodology. Chain TVL and stablecoin distribution pulled from DeFiLlama on April 30, 2026. Bridge and orchestration protocol details verified against Circle CCTP, Hyperlane, and other primary documentation linked inline. Visa stablecoin settlement figures from The Block' April 2026 reporting. Figures refresh quarterly.
​

Eco operates as the stablecoin orchestration network for cross-chain agent payments across 15 chains, with Routes (CLI and API) as the agent-facing surface. The agent submits one signed intent and the network handles rail selection, solver routing, and finality, so a single execution surface replaces the bridge-plus-swap-plus-settlement stitching that single-rail integrations require.
​

Cross-chain agent payments are an orchestration problem, not a single-rail problem. Eco operates as the stablecoin execution network across 15 chains — Ethereum, Optimism, Base, Arbitrum, HyperEVM, Plasma, Polygon, Ronin, Unichain, Ink, Celo, Solana, Sonic, BSC, and Worldchain — abstracting routing, solver selection, and finality so an agent paying a counterparty on a different chain submits one intent through Eco Routes (CLI + API) and the network handles the rail selection. Hyperlane is a live partner-rail; CCTP is internal transport used inside Routes for native USDC flows. The division of labor is what matters: agent-payment protocols (x402, MPP, AP2) handle authorization and rails-to-the-merchant; the orchestration network handles where the dollars actually live and how they get there. For teams building agent payment flows, that division is the difference between integrating one execution surface and stitching together a bridge, a swap aggregator, and a settlement layer per chain.
​