A procurement bot renews a software contract at 2 a.m. A travel agent rebooks a flight after a cancellation, without waking anyone up. A treasury agent moves idle cash between two accounts to capture an overnight rate. None of these actions involved a human clicking “confirm,” and that is precisely the problem compliance teams are now paid to solve. The question is no longer whether an AI agent initiated a transaction — that already happens thousands of times a day across banks, card networks, and SaaS platforms. The question is whether anyone can prove, after the fact, which human authorized that agent, what it was allowed to do, and how quickly its access can be shut off. That proof is what the industry has started calling Know Your Agent, or KYA.
Quick Answer
There is no single “Know Your Agent” standard yet. Four frameworks currently compete for the job of vetting AI agents before they transact: Google’s Agent Payments Protocol (AP2), which uses cryptographically signed mandates and launched with more than 60 partner organizations including Mastercard, American Express, PayPal, and Coinbase; Visa’s Trusted Agent Protocol, which lets merchants and issuers recognize legitimate agent traffic inside existing card rails; Mastercard’s Agent Pay, which extends its tokenization network with a registry of certified agents; and open, portable identity built on W3C Decentralized Identifiers and Verifiable Credentials. Pick based on four questions: who bears liability when the agent is wrong, how fast you can revoke its access, whether the credential works outside one vendor’s walled garden, and whether a regulator can reconstruct the delegation chain from a single transaction record.
The Decision Framework: Four Questions Before You Vet a Single Agent
Most compliance teams reach for KYA the way they reached for KYC a decade ago — as a vendor selection exercise. That instinct skips a step. Before comparing frameworks, a team needs to answer four questions about its own risk posture, because the “right” answer to Know Your Agent looks different for a bank issuing agent-enabled cards than it does for a mid-market SaaS company letting a chatbot renegotiate vendor contracts.
1. Who is the accountable human, and how far can the agent stray from their intent?
Every agent needs a named principal — a person or a legal entity that owns the consequences of what the agent does. The framework you choose should make that binding explicit at the moment of the transaction, not reconstructable later from server logs. If your agents operate with a fixed, narrow mandate (pay this invoice, up to this amount, to this payee), a lighter-weight signed-mandate approach may be enough. If agents negotiate terms or select among multiple counterparties, you need a framework that captures the boundaries of that discretion, not just the final action.
2. What is your revocation SLA?
KYC is largely a point-in-time check: verify the person once, refresh periodically. KYA cannot work that way, because an agent’s risk profile can change in the time it takes to read this sentence — a compromised API key, a prompt-injection attack, a runaway loop. The real question to ask any vendor is not “can you revoke access” but “how many seconds does revocation take, and does it propagate to every merchant or bank that already trusted that agent’s credential?”
3. Do you need portability across counterparties, or is a closed loop acceptable?
A card-network approach like Visa’s or Mastercard’s works well if most of your agent’s spend happens on card rails with participating merchants. A protocol like AP2, built to be rail-agnostic, matters more if your agents also touch bank transfers, stablecoins, or B2B invoicing outside the card networks. Decentralized identifiers matter most if you need an agent’s credential to be verifiable by a party you have never contracted with — a regulator, an auditor, or a counterparty on the other side of the world.
4. What does your regulator actually expect you to produce?
In the United States, FinCEN’s 2026 guidance on AI-initiated payments does not mandate a specific technology, but it does expect institutions to reconstruct, on request, the full delegation chain behind any flagged transaction: who authorized the agent, what scope it was given, and what evidence proves the agent stayed inside that scope. In the European Union, the incoming Payment Services Regulation replaces PSD2’s strong customer authentication rules with language that assumes a human is present to authenticate — agentic transactions do not fit that model cleanly, and national supervisors have started asking banks how they map an autonomous action back to a “customer instruction.” Whichever framework you pick, it needs to produce that mapping in a format your specific regulator will accept.
Who owns this decision inside your organization?
At most companies, no single department currently owns agent verification. Security teams think of it as an authentication problem, compliance teams think of it as a KYC-adjacent problem, and product teams think of it as an integration detail to be handled by whichever engineer is wiring up the payment API. That ambiguity is exactly why so many organizations end up with three different agents, deployed by three different teams, each using a different — or no — verification framework. Before evaluating vendors, name one accountable owner, typically a compliance or risk officer with a direct line to engineering, and require every new agent deployment to route through that person’s sign-off, regardless of which department built the agent.
Evaluation Criteria: What “Vetting an Agent” Actually Means
Vendors selling agent-identity products tend to bundle five distinct capabilities under one marketing term. Unbundling them is the single most useful thing a compliance officer can do before signing anything.
Identity and provenance
Can the system prove, cryptographically, which piece of software actually sent a given request — not just which company built it, but which specific deployed instance, running which model version, under whose API key? Weak implementations stop at “this request came from a valid API key,” which tells you nothing about whether the agent behind that key was compromised, misconfigured, or acting outside its intended purpose.
Authorization scope
A credential that only proves identity is half the job. The other half is proving what the agent was permitted to do at the moment it acted: a spending cap, a list of approved payees, a time window, a category restriction. Google’s AP2 handles this through two linked artifacts — an Intent Mandate, which captures what the human authorized in general terms, and a Cart Mandate, which captures the specific, final transaction the agent is about to execute. Both are signed and non-repudiable, which means neither the user nor the agent can later deny having agreed to the terms captured at that moment.
Revocability and the kill switch
Ask specifically whether revocation is centralized (one call-off switch that every relying party checks in near-real time) or federated (each merchant or bank caches trust for some period, meaning a revoked agent might still transact for minutes or hours after being cut off). Federated caching is common in card-network models for performance reasons, and it is the single biggest source of residual risk in agent frameworks today.
Liability allocation
When an agent authorizes a fraudulent or erroneous transaction, who eats the loss — the platform that built the agent, the bank that issued the credential, or the merchant that accepted it? Card-network frameworks tend to extend existing chargeback and liability-shift rules to agent transactions, which gives you a familiar dispute process but inherits card-network dispute timelines. Protocol-based frameworks like AP2 rely on the signed mandate itself as evidence in a dispute, which can be faster to resolve but depends on every party in the chain actually validating signatures rather than trusting them blindly.
Auditability
Can a third party — an internal auditor, an external examiner, a court — independently verify the full chain of custody for a transaction without needing privileged access to your systems? This is where portable, standards-based credentials (W3C Verifiable Credentials and Decentralized Identifiers) have a structural advantage: the proof travels with the credential rather than living exclusively inside one vendor’s database.
Options Comparison: The Four Live Frameworks
None of these four approaches is universally “best.” Each optimizes for a different combination of the criteria above, and most large financial institutions will end up running more than one simultaneously — a card-network protocol for retail-style purchases, and a protocol- or credential-based approach for everything that happens off the card rails.
| Framework | Backed By | Verification Mechanism | Revocation | Best Fit |
|---|---|---|---|---|
| Agent Payments Protocol (AP2) | Google, with 60+ partners including Mastercard, Amex, PayPal, Coinbase | Signed Intent and Cart Mandates, rail-agnostic | Near-real time, protocol-native | Multi-rail commerce, bank transfers, stablecoins |
| Visa Trusted Agent Protocol | Visa network and issuing banks | Signed HTTP-layer agent signal recognized by merchants | Federated, cached at merchant edge | Card-present-style retail agent purchases |
| Mastercard Agent Pay | Mastercard network | Agentic Tokens layered on existing tokenization, certified-agent registry | Token-level, minutes | Issuers already on Mastercard’s tokenization stack |
| W3C DID / Verifiable Credentials | Open standard, no single commercial owner | Portable cryptographic credential, independently verifiable | Depends entirely on issuer’s revocation registry design | Cross-border, cross-institution, regulator-facing proof |
The trade-off that matters most in practice is speed of implementation versus portability. A card-network approach can be live in weeks because it reuses rails your acquiring bank and merchants already trust. A standards-based credential approach takes longer to stand up because you are building the trust relationships yourself, but the resulting proof does not depend on any single network staying in business or keeping its API stable.
Typical Time-to-Production, by Framework (weeks, early-adopter estimates)
4 wks
5 wks
6 wks
14 wks
Dashed line marks the zero-integration baseline. Ranges reflect self-reported timelines from early enterprise pilots and vary heavily by existing card-network relationships and internal engineering capacity.
Worked Example: Vetting an Expense-Reconciliation Agent at a 200-Person Company
A finance operations lead at a 200-employee logistics company wants to deploy an agent that reconciles vendor invoices against purchase orders and initiates ACH payments for anything under $5,000 that matches exactly. Above that threshold, it routes to a human. The company has no card-network relationship that matters here, since the payments run over ACH, not cards, and it has no interest in building its own credential infrastructure from scratch.
Walking through the four decision questions: the accountable human is the controller, and the agent’s discretion is narrow — match or don’t match, pay or escalate, nothing in between. The revocation SLA needs to be tight, because a misconfigured matching rule could trigger duplicate payments before anyone notices. Portability barely matters, since the agent only ever talks to one bank’s payment API. The regulator that matters is the bank’s own risk team, which wants a clean audit trail more than it wants a specific brand of cryptography.
Given that profile, a signed-mandate approach modeled on AP2’s Intent and Cart Mandate pattern fits better than either card-network option, since ACH sits outside the card rails entirely, and it fits better than a full DID/VC rollout, since the company only needs one bank to trust the credential, not the general public. The controller signs a standing Intent Mandate capping the agent at $5,000 per invoice and a defined vendor list; every payment the agent initiates carries its own Cart Mandate referencing that standing authorization. The bank’s system checks the signature chain before releasing funds, and revocation is a single API call that invalidates every future Cart Mandate tied to that Intent Mandate instantly. Six weeks after signing the integration agreement, the agent is live, and the first internal audit six months later reconstructs every payment back to a named signature in under an hour.
Common Mistakes Compliance Teams Make with Agent Verification
Treating agent verification as a one-time onboarding event
The habit KYC built over twenty years — verify once, review annually — does not survive contact with software that can be silently modified, re-deployed, or compromised between review cycles. An agent’s credential needs continuous attestation, not an annual checkbox.
Confusing “the agent is authentic” with “the transaction is authorized”
Proving that a request genuinely came from Agent X tells you nothing about whether Agent X was supposed to make that particular request. Teams that stop at identity verification and skip scope verification end up unable to explain, after a bad transaction, why the agent was allowed to do what it did.
Assuming card-network trust automatically covers non-card payments
A company that rolls out Visa’s or Mastercard’s agent framework for retail purchases sometimes assumes the same trust extends to bank transfers, invoicing, or crypto rails. It does not. Each rail needs its own verification path, and gaps between rails are exactly where fraud concentrates.
Ignoring cache latency in revocation
A federated trust model that caches an agent’s credential at the merchant edge for even fifteen minutes creates a window where a revoked agent can still transact. Ask vendors for the actual cache TTL, not just the marketing claim that revocation is “instant.”
Leaving liability language vague in the agent’s own terms of service
Several early agent-commerce disputes stalled because the platform’s terms never specified who absorbs the loss when an agent misinterprets an instruction. That gap gets discovered during a dispute, which is the worst possible time to discover it.
Building a bespoke credential system instead of adopting an open one
Proprietary, in-house agent-identity systems look appealing because they are fully controlled, but they fail the auditability test the moment a regulator or counterparty outside your organization needs to independently verify a credential. Open standards exist specifically so a third party doesn’t have to trust your internal database.
Grading every agent’s verification maturity as if it were still unverified by default
A dangerous habit shows up once a company has rolled out a verification framework for its flagship agent: everyone assumes the framework now covers every agent, including the ones spun up later by a marketing team or a regional office using a different vendor’s tooling. Verification frameworks do not inherit automatically across departments or subsidiaries. Every new agent should be treated as unverified until it is explicitly enrolled, no matter how mature your organization’s overall program looks on paper.
Practical Checklist: Rolling Out Agent Verification
- Inventory every agent currently authorized to move money or data on behalf of your organization, including ones deployed by individual teams outside a formal procurement process.
- For each agent, name the accountable human or role, not just the department.
- Define the scope boundary in writing — spend cap, payee list, category, time window — before the agent goes live, not after an incident.
- Choose a verification framework based on the rail the agent actually transacts on, not the rail your compliance team is most familiar with.
- Confirm the vendor’s actual revocation propagation time in writing, and test it before launch, not during an incident.
- Map your regulator’s specific evidentiary requirement — what document or record they will accept as proof of delegation — and confirm your chosen framework produces it natively.
- Put liability allocation in the agent’s terms of service and in your contract with the platform vendor, explicitly, before the first transaction runs.
- Run a tabletop exercise simulating a compromised agent credential and time how long full revocation and containment actually takes.
- Re-certify every agent’s scope quarterly, treating configuration drift as seriously as you would treat a lapsed KYC file.
Key Takeaways
- Know Your Agent is not one technology — it is a category with at least four competing, partially overlapping frameworks, and most institutions will end up using more than one.
- Identity, authorization scope, revocability, liability, and auditability are five separate capabilities that vendors routinely bundle together; unbundle them before you buy.
- Card-network frameworks (Visa’s Trusted Agent Protocol, Mastercard’s Agent Pay) integrate fastest for retail-style card purchases but inherit federated caching that can delay revocation.
- Rail-agnostic protocols like Google’s AP2 fit best for organizations moving money across card, bank, and stablecoin rails from a single agent fleet.
- Open, portable credentials built on W3C standards take longer to deploy but produce proof that a regulator or outside auditor can verify without trusting your internal systems.
- Regulators are not mandating a specific technology yet — they are mandating that you can reconstruct the delegation chain behind any flagged transaction on request.
Frequently Asked Questions
What is the difference between KYC, KYA for crypto addresses, and Know Your Agent?
KYC verifies the identity of a human customer. A related but distinct concept, also sometimes shortened to KYA, verifies the behavior of a blockchain address rather than a person — that framework is covered in depth in our guide to the shift from KYC to KYA in crypto compliance. Know Your Agent, the subject of this article, is a third and newer concept: verifying that a piece of autonomous software acting on someone’s behalf is authentic, properly authorized, and revocable, regardless of whether the underlying payment ever touches a blockchain.
Is there a single Know Your Agent standard that regulators require today?
No. As of late 2026, FinCEN’s guidance and the EU’s evolving payment services rules describe outcomes institutions must achieve — a reconstructable delegation chain, clear liability allocation — without mandating a specific protocol. That leaves the choice of framework to individual institutions, which is why comparing frameworks against your own risk profile matters more than picking whichever one is most talked about.
Can a small business realistically adopt any of these frameworks without a card-network relationship?
Yes. Signed-mandate approaches modeled on AP2’s Intent and Cart Mandate structure, or a lightweight verifiable-credential setup with a single banking partner, do not require a card-network integration at all. They require a bank or payment processor willing to check signatures, which is a much lower bar than joining a card network’s certified-agent program.
What happens if an agent’s credential is stolen or spoofed?
The framework’s revocation speed determines the damage window. A centrally revocable, protocol-native credential can be invalidated in seconds, and every relying party checking that revocation in near-real time stops honoring it immediately. A federated, cached credential may still be honored by some merchants or partners for as long as their cache holds, which is why cache TTL is one of the most important — and most overlooked — numbers to negotiate with any vendor.
Does adopting a Know Your Agent framework replace the need for traditional fraud monitoring?
No. Verifying that an agent is authentic and authorized reduces one category of risk — impersonation and scope creep — but it does not replace behavioral fraud monitoring, which still needs to watch for an authorized, authentic agent doing something anomalous within its own permitted scope.
References
- Financial Crimes Enforcement Network (FinCEN): Guidance on AI-Initiated Payment Transactions and Delegated Authority (2026).
- European Commission: Proposal for a Regulation on Payment Services (PSR) and accompanying Payment Services Directive (PSD3) texts.
- World Wide Web Consortium (W3C): Verifiable Credentials Data Model v2.0 and Decentralized Identifiers (DIDs) v1.0 specifications.
- National Institute of Standards and Technology (NIST): Special Publication 800-63-4, Digital Identity Guidelines.
- Google: Agent Payments Protocol (AP2) technical overview and partner announcement materials.
- Visa: Trusted Agent Protocol program documentation for issuers and merchants.
- Mastercard: Agent Pay and Agentic Tokens program overview.
- FIDO Alliance: Working group materials on device-bound attestation for non-human and agentic identities.
Disclaimer: This article is for informational purposes only and does not constitute legal, compliance, or financial advice. Regulatory expectations for AI agent verification are evolving quickly and vary by jurisdiction and industry. Consult a qualified compliance or legal professional before implementing any agent-verification framework.
