Answer box: Agent interoperability across banks means an AI agent acting on a customer’s behalf can be recognized, authenticated, and given a spending limit at one bank, then carry that same verified authority into a transaction with a completely different bank or card network. It works today through a patchwork of emerging protocols — Google’s Agent Payments Protocol (AP2), Visa’s Trusted Agent Protocol, Mastercard’s Agent Pay tokenization, OpenAI and Stripe’s Agentic Commerce Protocol, and the older Financial Data Exchange (FDX) API standard for account data — none of which is universal yet. For payments, risk, and product leaders at banks and credit unions, the practical task in 2026 is not picking a single winner but deciding which of these overlapping rails to support first, how to attribute liability when an agent misfires, and how to avoid the compliance gaps that show up when a mandate signed at one institution has to be honored by another.
Why This Matters Now for Bank Payments, Risk, and Product Teams
For most of the last decade, “interoperability” in banking meant one thing: can a customer’s data move safely between institutions through an API instead of a screen-scraping script. The Financial Data Exchange consortium solved a large share of that problem for account data. Payment interoperability across networks was handled by card rails, ACH, and wire — slow to change, but predictable, and built around the assumption that a human was the one clicking “confirm.”
That assumption broke in the second half of 2025. Within about six weeks of each other, Google published the Agent Payments Protocol as an open specification with more than sixty named partners across banking, card networks, and commerce platforms; Visa introduced its Trusted Agent Protocol to let issuers flag that a transaction was initiated by software rather than a person; Mastercard extended its tokenization stack into what it calls Agent Pay; and OpenAI and Stripe launched the Agentic Commerce Protocol to let a chatbot complete a purchase without redirecting the shopper to a merchant’s website. Coinbase and Cloudflare pushed a stablecoin-native alternative, x402, for machine-to-machine micropayments that skip card rails entirely.
None of this happened because banks asked for it. It happened because consumer-facing AI assistants started being able to shop, book, and rebalance on a person’s behalf, and the card networks and cloud platforms moved first to make sure the resulting transactions ran over rails they control. Banks are now in the position of retrofitting identity, fraud, and liability frameworks that were built for humans onto a class of actor — the autonomous or semi-autonomous agent — that the original rulebooks never contemplated. For a payments or risk leader, the urgency is less about chasing a hot trend and more about closing a specific gap: existing Regulation E and Regulation Z consumer-protection language assumes a human authorized (or failed to authorize) a transaction, and that binary doesn’t map cleanly onto a mandate an agent executed inside parameters a customer set days earlier.
The audience this guide is written for sits at three types of institutions: mid-size and regional banks deciding whether to support agent-initiated payments at all in the next product cycle; credit unions and community banks watching card network mandates arrive as fait accompli through their processors; and fintech and embedded-finance teams building agent-facing products on top of bank partners who haven’t yet published a policy on the subject. All three groups need the same grounding: what the protocols actually do, where liability currently sits, and what breaks first when two institutions’ agent stacks try to talk to each other.
Mandates, Not Passwords: How an Agent Proves It’s Allowed to Spend
The core interoperability problem is authorization, not connectivity. Two banks can already move money to each other every day. What neither bank can currently do reliably is answer a narrower question: did this specific AI agent have permission, at this moment, for this amount, on behalf of this customer, and can that permission be verified by a party who never talked to the customer directly?
AP2 answers this with a structured object called a mandate — a cryptographically signed record of what the user actually authorized. Google’s specification splits this into an intent mandate, created when the user tells the agent what they want in general terms (“find me a hotel under $220 a night near the airport for the 14th”), and a cart mandate, created at the moment of purchase once the agent has assembled a specific, priced item for the user to approve, either explicitly or under pre-set autonomous limits. Both mandates are signed using verifiable credentials, so a receiving party — a merchant’s payment processor, a card issuer, another bank — can check the signature without needing a live call back to the originating institution.
Visa’s Trusted Agent Protocol takes a narrower slice of the same problem and bolts it onto the existing card authorization message. Rather than inventing a new mandate object, TAP adds an attestation field that tells the issuing bank, at the moment of authorization, that the request came from a known, registered agent rather than an unknown script or a compromised credential. The issuer still makes its own approve or decline decision, but now with a new signal it didn’t have before. Mastercard’s approach layers scoped tokens on top of its existing tokenization service: instead of a generic card token, an agent gets a token constrained to a merchant category, a spend ceiling, and an expiration, provisioned by the issuing bank and revocable the moment the customer wants to shut the agent off.
The practical consequence for interoperability is that a mandate created under one scheme does not automatically translate into another. A cart mandate signed under AP2 has no native meaning to a card processor that only understands TAP’s attestation field, and neither has any bearing on an ACH transfer initiated through a bank’s own agent-facing API. Institutions that want to support agent-initiated payments across multiple channels currently have to implement translation logic — or pick their battles and support the one or two rails their highest-volume partners actually use.
The Protocol Stack: Where Each Standard Actually Sits
It helps to think of the current landscape as four layers stacked on top of each other rather than four competing replacements for the same thing.
At the bottom sits data access — can an agent even see a customer’s balances, transaction history, and account list across institutions? This is the job FDX already does for human-initiated account aggregation, and it is the layer agent developers lean on most heavily today because it predates the current wave of agent-specific protocols by nearly a decade. Above that sits identity and consent — proving that a specific agent has a specific customer’s authorization, which is where AP2’s mandates and Visa’s TAP attestation operate. Above that sits the settlement rail itself — card network, ACH, wire, RTP, or a stablecoin rail like the one x402 is built for — which determines how the money actually moves and what dispute rights attach to it. And at the top sits the commerce layer — the checkout experience itself, which is what Stripe and OpenAI’s Agentic Commerce Protocol standardizes so a merchant’s product catalog and checkout flow can be exposed to a chatbot without a full website redirect.
A bank rarely has to choose just one of these layers to engage with, but it does have to decide where its own exposure is highest. An issuing bank cares most about the identity and settlement layers, because that’s where its approve-or-decline decision and its liability sit. A bank running its own aggregation or wealth product cares more about the data-access layer, because that’s what determines whether a third-party agent can see a customer’s full financial picture accurately enough to act on it. A bank with a merchant-acquiring business cares most about the commerce layer, because that’s where disputes about “the agent bought the wrong thing” will land first.
Identity, Attestation, and the Liability Question Nobody Has Fully Settled
The hardest open question in cross-bank agent interoperability is not technical. It’s who eats the loss when something goes wrong — an agent buys the wrong item, exceeds a limit it should have respected, or gets manipulated by a prompt-injection attack embedded in a merchant’s product page.
Existing consumer protection law wasn’t written with this in mind. Regulation E governs electronic fund transfers and gives consumers strong protection against unauthorized transactions, but its definition of “authorized” assumes a person made or approved the transfer. Regulation Z’s chargeback framework for credit cards similarly assumes a cardholder disputing a charge they didn’t recognize or didn’t receive value for. An agent acting inside a mandate the customer genuinely set — but making a judgment call the customer wouldn’t have made themselves — sits in a gray zone that neither rule anticipates cleanly. Was the transaction “authorized” because the mandate existed, or “unauthorized” because the specific purchase wasn’t something the customer would have approved if asked in the moment?
Card networks have moved fastest here because they control both the authorization message and the dispute rulebook. Visa’s TAP attestation and Mastercard’s scoped tokens both create a paper trail that shifts practical liability toward whichever party’s agent registration was defective — if an issuer approved a transaction from an agent that was properly registered and within its mandate limits, network rules increasingly point toward treating that as a good authorization, even if the customer is unhappy with the outcome. Where a bank hasn’t adopted either scheme yet, agent transactions still run through ordinary card-not-present rules, which generally leave the bank and merchant to sort out liability through standard dispute codes — a process not designed for the volume or nature of agent-driven disputes now emerging.
The interoperability wrinkle shows up when the agent, the issuing bank, and the merchant’s acquiring bank are on three different protocol versions. An issuer that has implemented TAP can flag a transaction as agent-initiated. If the acquiring side and the merchant’s payment processor haven’t implemented anything that reads that flag, the signal gets dropped and the transaction is treated as an ordinary card-not-present sale — meaning the extra protection the issuer thought it was building into the flow provides no actual benefit for that specific transaction. Interoperability failures in this space rarely look like an outright rejected transaction; they look like a signal that silently disappears somewhere in the middle of the chain.
The Data Layer Underneath: FDX, Open Banking, and the Access Problem That Predates All of This
Before an agent can act intelligently across multiple banks, it needs permissioned read access to balances, transaction history, and account details at each one. This is the oldest and, in some ways, best-solved layer of the stack. The Financial Data Exchange standard, backed by a consortium that includes most large U.S. banks, card networks, and aggregators such as Plaid, MX, and Akoya, replaced the earlier era of screen-scraping — where a fintech app stored a customer’s actual online banking password and logged in as if it were the customer — with token-based, permissioned API access. A large majority of major U.S. retail deposit accounts now sit behind FDX-conformant APIs rather than scraped credentials.
That data layer becomes the substrate agent developers build on, because an agent that manages money across accounts at three different banks has to pull consistent, structured data from all three before it can make a useful decision. Where FDX adoption is inconsistent — smaller community banks and some credit unions still lag larger institutions in publishing conformant APIs — agents fall back to scraping or third-party data providers with weaker consent trails, which reintroduces exactly the security and liability ambiguity FDX was built to eliminate.
The regulatory backdrop matters too. The Consumer Financial Protection Bureau’s Personal Financial Data Rights rule, issued under Section 1033 of the Dodd-Frank Act, was designed to give consumers an enforceable right to have their financial data shared with authorized third parties, including — implicitly — AI agents acting under a consumer’s direction. That rule has been contested in litigation brought by banking trade groups, and implementation timelines have shifted as a result, which means the legal floor under agent data access is less settled than the technical standard sitting on top of it. A bank’s FDX conformance says nothing about whether it has fully resolved its obligations under the rule as litigation plays out — those are two different compliance tracks that happen to intersect at the same API.
A Worked Example: One Purchase, Three Verification Layers
Consider a travel-booking agent a customer has authorized to book a hotel room up to $250 a night, funded from a checking account at Bank A, with the actual card transaction running through a card issued by Bank B. The agent finds a $214.63 room, generates a cart mandate, and submits it. Here is roughly how the flow allocates time and responsibility across the stack, expressed as an illustrative breakdown rather than a universal timing standard, since actual latency varies by implementation.
Illustrative time allocation across verification steps for a $214.63 agent-initiated booking
Illustrative allocation of process weight for a mandate-based agent transaction; actual latency and sequencing vary by protocol implementation and issuer infrastructure.
The interoperability failure point in this example is almost never the settlement step — ACH and card rails move money reliably once a transaction is approved. It’s the second step. Bank A originated the mandate and trusts it completely. Bank B, the card issuer, has never seen this customer’s agent before and has to decide, in real time, whether to trust an attestation it received secondhand. If Bank B hasn’t implemented a way to read AP2 mandates or TAP attestations from an institution it has no direct relationship with, it typically falls back to treating the transaction as an ordinary card-not-present purchase — which still gets approved most of the time, but without the extra fraud and liability protection the mandate was designed to provide, and with less certainty about which party absorbs a dispute if the booking turns out to be wrong.
Protocol Comparison at a Glance
| Protocol | Primary sponsor(s) | Rail type | Core mechanism | Bank’s role |
|---|---|---|---|---|
| AP2 (Agent Payments Protocol) | Google, with card networks, PayPal, Coinbase, and other partners | Rail-agnostic (card, bank transfer, crypto) | Signed intent and cart mandates using verifiable credentials | Verify mandate signature before authorizing |
| Trusted Agent Protocol (TAP) | Visa | Card rails | Attestation field added to the authorization message | Issuer reads the attestation and decides approve or decline |
| Agent Pay / Agentic Tokens | Mastercard | Card rails | Scoped tokens limited by merchant category, amount, and expiry | Issuer provisions and can revoke the scoped token |
| Agentic Commerce Protocol (ACP) | OpenAI and Stripe | Existing card rails via processor | Structured checkout API exposing merchant catalog and pricing to a chat agent | Largely unchanged; risk stays with existing card-not-present rules |
| x402 | Coinbase and Cloudflare | Stablecoin / crypto rail | HTTP-native machine-to-machine micropayment flow | Typically none, unless a bank operates the fiat on/off-ramp |
| FDX API | Financial Data Exchange consortium (banks, aggregators, fintechs) | Data access, not payment | Standardized, token-based read API replacing screen-scraping | Publishes conformant API; sets consumer consent scope |
Common Mistakes Banks and Fintechs Make When Wiring Up Agent Rails
The first and most common mistake is treating agent interoperability as a single integration project rather than a layered decision. A team implements TAP on the card side and assumes it has “solved” agent payments, without realizing that a customer’s checking-account transfers, bill pay, and internal money movement run through none of that infrastructure at all.
The second is under-scoping spend limits on agent-facing tokens. A scoped token set to a generous ceiling “to avoid declined transactions” defeats the purpose of scoping in the first place — the entire liability argument for adopting Agent Pay or a similar scheme rests on the limit being tight enough that an issuer can point to it as meaningful risk control, not a formality.
The third mistake shows up on the dispute-handling side: banks that adopt an agent-attestation field on the authorization message but never update their internal fraud and chargeback playbooks to actually use that field when a customer calls in confused about a transaction. The signal exists in the data but nobody downstream is trained to look at it, so agent-flagged disputes get routed through the same manual process as everything else, and the extra context is wasted.
The fourth is assuming FDX conformance and agent-payment readiness are the same project. They aren’t. A bank can have excellent FDX-based data-sharing infrastructure and still have no way for an agent to actually initiate a payment on a customer’s behalf, because data access and payment initiation sit on different layers of the stack described earlier.
The fifth mistake is smaller institutions waiting for a single dominant standard to emerge before building anything. Given how fast the card networks and Google have moved, that wait risks a bank showing up two or three years late to infrastructure its own processor may quietly implement on its behalf anyway — usually with default settings the bank never explicitly reviewed or agreed to.
A Readiness Checklist for Bank Payments, Risk, and Product Leaders
- Confirm whether your card processor or core provider has already implemented TAP, Agent Pay, or an equivalent agent-attestation feature on your behalf, even if nobody at your institution requested it.
- Map which of your product lines are exposed to agent-initiated activity today — card-not-present purchases, bill pay, P2P transfers, brokerage or wealth transactions — and rank them by dollar volume at risk.
- Verify your FDX conformance status directly rather than assuming your aggregator relationship covers it; conformance level varies by data category (balances, transactions, statements) and by API version.
- Update fraud and dispute-handling procedures to reference agent-attestation fields where they exist, so front-line staff and automated fraud models actually use the new signal instead of ignoring it.
- Set explicit internal policy on scoped-token limits for agent-facing products rather than defaulting to standard card limits, and document the rationale for whatever ceiling you choose.
- Review your customer agreements and Regulation E disclosures for language that assumes a human initiated every electronic transfer, and flag gaps to legal and compliance before agent volume grows.
- Pick one interoperability layer to prioritize based on your business model — data access for aggregation-heavy products, identity and settlement for card-issuing businesses, commerce integration for merchant-acquiring lines — rather than trying to implement all four at once.
- Track the Section 1033 litigation timeline separately from your technical FDX roadmap, since a change in the regulatory floor could alter consent requirements independent of what your API already supports.
Institutions building consumer-facing agent products alongside these bank-side changes are also watching how autonomous financial identities are evolving more broadly — a related shift covered in this look at the rise of agentic wallets, which walks through how AI agents are being given the ability to hold and spend funds directly rather than only initiating transactions on a human’s behalf.
Key Takeaways
- Agent interoperability across banks is currently solved in layers, not as a single standard — data access (FDX), identity and consent (AP2, TAP), settlement (card, ACH, stablecoin rails), and commerce (ACP) each move at a different pace.
- Google’s AP2, Visa’s TAP, and Mastercard’s Agent Pay all emerged within roughly the same few months of late 2025, and none of them is a drop-in replacement for the others — a mandate signed under one scheme has no native meaning to a system that only understands another.
- Liability for agent-initiated transactions still runs largely through existing card network dispute rules and consumer protection law that wasn’t written with autonomous agents in mind, creating gray areas around what counts as an “authorized” transaction.
- FDX-based data access is the most mature layer of the stack and the one most agent products already depend on, but conformance still varies meaningfully between large banks and smaller institutions.
- The most common integration failure isn’t a rejected transaction — it’s a trust or attestation signal that silently drops when it crosses from an institution that implemented a protocol to one that hasn’t.
Frequently Asked Questions
What does “agent interoperability across banks” actually mean in practice?
It means an AI agent that a customer has authorized at one institution — for example, a shopping or travel-booking assistant — can carry that authorization into a transaction that touches a different bank, card issuer, or payment network, and have that authorization recognized and verified without a human re-confirming every step.
Is there one universal standard that all banks use for agent payments?
No. As of early 2026, banks and payment networks are working from several overlapping but distinct specifications, including Google’s Agent Payments Protocol, Visa’s Trusted Agent Protocol, Mastercard’s Agent Pay tokenization, and the OpenAI-Stripe Agentic Commerce Protocol, alongside the older FDX standard for account data access. Institutions typically support whichever of these their processor, core provider, or key partners have already adopted.
Who is liable if an AI agent makes an unauthorized or mistaken purchase?
Liability currently depends on which protocol was involved and whether the agent stayed within its documented spend limits and merchant category restrictions. Card network rules increasingly treat a properly registered, mandate-compliant agent transaction as an authorized purchase even if the customer disagrees with the outcome, while transactions that fall outside an agent’s registered scope are more likely to be treated as errors or unauthorized activity subject to standard dispute processes.
How does FDX relate to these newer agent payment protocols?
FDX solves data access — letting an agent see account balances and transaction history through a permissioned API instead of screen-scraping login credentials. It doesn’t handle payment initiation or agent identity verification on its own; those are addressed by the newer protocols like AP2, TAP, and Agent Pay, which sit on top of the data layer FDX already provides.
What should a smaller bank or credit union do if it hasn’t adopted any of these protocols yet?
Start by checking whether a card processor or core banking provider has already implemented agent-attestation features on the institution’s behalf, since many of these changes roll out through infrastructure providers rather than requiring a bank to build anything itself. From there, prioritize whichever layer matches the institution’s actual product exposure — data access for aggregation-heavy services, identity and settlement controls for card-issuing portfolios.
References
- Google Cloud — Agent Payments Protocol (AP2) technical overview and partner announcement
- Visa — Trusted Agent Protocol program overview
- Mastercard — Agent Pay and agentic tokenization program details
- OpenAI and Stripe — Agentic Commerce Protocol specification
- Financial Data Exchange (FDX) — API specification and conformance program
- Consumer Financial Protection Bureau — Personal Financial Data Rights rule (Section 1033 of the Dodd-Frank Act)
- Coinbase and Cloudflare — x402 protocol documentation
