
Know Your Agent (KYA) Index 2027: AI Agent Identity, Trust and Authorization
DN maps the emerging Know Your Agent stack across A2A, ERC-8004, AuthZEN, AP2, Visa, Mastercard and agent identity standards for autonomous finance.
Know Your Agent (KYA) Index 2027
AI agents are beginning to spend money, call tools, negotiate contracts and transact with other autonomous systems. The next infrastructure problem is proving which agent is acting, who authorized it, what authority it actually has and whether another machine should trust it.
What Matters
“Know Your Agent” is rapidly becoming a real infrastructure category rather than a slogan.
On 10 September 2026, Visa, Mastercard and Ant International announced work on a shared Know-Your-Agent interoperability framework intended to help card networks, wallets, agent platforms and marketplaces recognize trusted AI agents across payment ecosystems.
That development joins a much broader standards race.
NIST is actively studying software and AI-agent identity and authorization. OpenID AuthZEN has a finalized Authorization API for policy decisions and is extending that architecture into agent tool authorization. A2A 1.0 supports discoverable Agent Cards and cryptographic signatures. ERC-8004 proposes portable agent identity, reputation and independent validation. AP2 and Mastercard Verifiable Intent focus on proving what a user actually authorized an agent to do.
But there is an important problem:
none of these layers alone answers every trust question.
Knowing an agent's identity does not prove that it was authorized to transfer $50,000.
Knowing that an action was authorized does not prove that the counterparty is reputable.
A five-star reputation score does not prove that the software presenting it has not been impersonated.
And a valid cryptographic signature does not prove that the signed action was wise.
The emerging solution is therefore a composable Agent Trust Stack, not one universal identity token.
Why KYA Suddenly Matters
The internet was designed around human and organizational accounts.
A person logs in.
A company receives an API key.
A service account has credentials.
An AI agent changes the structure.
The agent may be:
- created dynamically;
- delegated by another agent;
- operating for a human;
- operating for a company;
- using several tools;
- holding a wallet;
- talking to unknown counterparties;
- making thousands of decisions while its principal is offline.
That creates a new identity problem.
The counterparty may need to identify not only the software process, but the authority chain behind it.
The DN Agent Authority Chain
Decentralised News proposes a seven-link model for consequential autonomous actions.
The First Rule of KYA: Identity Is Not Authorization
Suppose an exchange receives a request from a cryptographically authenticated agent.
The exchange knows exactly which agent sent it.
That does not answer:
- Who owns the agent?
- Who instructed it?
- Was the agent authorized to trade this asset?
- Was it authorized to spend this amount?
- Was leverage permitted?
- Had its mandate expired?
- Was another approval required?
This is the same distinction that matters in conventional security:
authentication proves identity.
authorization determines permission.
Agents make that distinction economically critical because they can initiate financial actions autonomously and at machine speed.
The DN KYA Component Readiness Index
The technologies below are complementary. The score evaluates how ready each component is for the function it claims to perform, not whether one can replace another.
| Infrastructure | Primary Role | DN Role Readiness | Major Strength | Primary Gap | Status |
|---|---|---|---|---|---|
| OpenID AuthZEN | Deterministic authorization | 95/100 | Standard PEP/PDP policy decision interface | Not an agent reputation system | Core Final |
| A2A Signed Agent Cards | Discovery + agent endpoint integrity | 93/100 | Signed capability and security metadata | Identity card does not prove task authority | Standard |
| ERC-8004 | Portable identity + reputation + validation | 90/100 | Open cross-organizational trust primitives | Draft ERC and Sybil-sensitive reputation | Draft + Deployed |
| Mastercard Verifiable Intent / AP2 | Proof of delegated purchase intent | 90/100 | Cryptographic evidence of what user authorized | Focused primarily on commerce and payment | Rolling Adoption |
| Visa Trusted Agent Protocol | Trusted commerce-agent recognition | 88/100 | Payment-network merchant trust layer | Not a universal cross-domain agent identity system | Rolling Deployment |
| Visa + Mastercard + Ant KYA | Cross-network agent recognition | 82/100 | Potential payment ecosystem interoperability | Framework newly announced; public technical detail still limited | In Development |
| AIP / AgentID Internet-Drafts | Agent identity + delegation chains | 76/100 | Explicit cryptographic agent authority models | Early work, not IETF standards | Internet-Draft |
Scores are DN editorial readiness scores for the stated function, based on specification maturity, agent specificity, interoperability, cryptographic integrity, policy coverage, auditability and documented deployment. The technologies are not direct substitutes.
1. OpenID AuthZEN: The Strongest Deterministic Authorization Primitive
OpenID AuthZEN
OpenID AuthZEN addresses one of the least glamorous but most important questions in agentic finance:
Should this specific action be allowed?
The Authorization API 1.0 became an OpenID Final Specification in January 2026.
Its architecture standardizes communication between:
- a Policy Enforcement Point, which intercepts an attempted action;
- a Policy Decision Point, which evaluates whether that action is allowed.
The decision model uses:
- Subject;
- Action;
- Resource;
- Context.
That maps naturally to agents.
For example:
May Agent-487, acting for Treasury-Team-A, call the transfer tool for 10,000 USDC to Counterparty-B under the current risk context?
AuthZEN's emerging COAZ work extends this concept into agent tool calls and MCP.
The critical design advantage is that the final decision can remain deterministic even if the reasoning agent is probabilistic.
DN view: identity systems tell us who is asking. AuthZEN-class infrastructure provides a standardized way to ask whether that actor should be allowed to perform the requested action.
Explore OpenID AuthZEN2. A2A Signed Agent Cards: The Machine Business Card
A2A Signed Agent Cards
A2A's Agent Card functions like a machine-readable business card.
It can describe:
- the agent;
- its provider;
- service endpoints;
- supported protocols;
- authentication requirements;
- capabilities;
- skills.
The standard defines a well-known discovery location:
/.well-known/agent-card.json
A2A 1.0 also allows Agent Cards to be signed using JSON Web Signatures.
A verifying client can therefore establish that the card was not altered and that it was signed using the expected cryptographic identity.
That is important.
If a malicious discovery service silently changes the payment endpoint on an agent's card, every downstream trust control may operate on the wrong counterparty.
But a signed card still has limits.
It can establish integrity and provenance of the advertised metadata.
It does not independently prove:
- that the advertised skill is actually competent;
- that the agent has permission for a particular transaction;
- that its reputation is genuine;
- that its principal approved today's action.
DN view: signed Agent Cards are an excellent discovery identity primitive. They should be treated as the beginning of trust evaluation, not the end.
Explore A2A 1.03. ERC-8004: The Most Interesting Open Reputation Layer
ERC-8004
ERC-8004 targets a different problem:
How can an autonomous agent evaluate another autonomous agent when the two parties do not already share an enterprise identity system?
The proposal introduces three registries.
Identity Registry
An agent receives a portable identifier based on an ERC-721 registry.
Its registration file can advertise:
- web endpoints;
- A2A endpoints;
- MCP endpoints;
- ENS names;
- DIDs;
- wallet information;
- supported trust models;
- x402 compatibility.
Reputation Registry
Counterparties can publish standardized feedback signals.
The registry exposes those signals to other contracts and applications while allowing more sophisticated aggregation to happen offchain.
Validation Registry
Independent validators can record verification results.
The ERC explicitly contemplates mechanisms including:
- stake-secured re-execution;
- zero-knowledge machine-learning proofs;
- trusted execution environment attestations;
- trusted judges and external validators.
The Ethereum Foundation's current AI-agent documentation says ERC-8004 registry infrastructure is deployed across multiple networks.
But the ERC itself remains a Draft.
DN view: ERC-8004 could become extremely important because open agent markets need portable economic history. But the value will increasingly sit in reputation interpretation, validator quality and Sybil resistance rather than raw feedback count.
Read ERC-8004DN Reputation Purity
A future agent marketplace may display:
4.98 / 5 rating from 23,491 agent interactions.
That number can be almost meaningless if:
- the same operator controls the reviewers;
- reviewers were created yesterday;
- transactions were economically circular;
- reviewers paid almost nothing;
- feedback was incentivized;
- identities can be recreated cheaply after failure.
Ten independent counterparties risking real economic value may be more informative than 100,000 cheap anonymous ratings.
4. Mastercard Verifiable Intent and AP2: Identity Is Not Enough
Mastercard Verifiable Intent + AP2
Mastercard Verifiable Intent tackles the problem from another direction.
The payment ecosystem may already know:
- the consumer;
- the payment credential;
- the merchant;
- possibly the agent.
What becomes less visible in autonomous commerce is the human's original intent.
Did the user say:
“Buy any available flight under $1,000.”
or:
“Show me flights under $1,000 but do not buy anything.”
Those prompts can result in dramatically different legitimate authority.
Mastercard's Verifiable Intent initiative, aligned with Google's AP2 and UCP work, is designed to create cryptographic evidence of what the consumer authorized.
That can create a shared source of truth for:
- consumer;
- agent platform;
- merchant;
- payment network;
- issuer.
DN view: for financial agents, the long-term identity primitive may need to prove not merely “which software acted,” but “which delegated intention caused this particular economic action.”
Explore Mastercard Verifiable Intent5. Visa Trusted Agent Protocol: Separate Good Agents From Bad Bots
Visa Trusted Agent Protocol
Merchants have spent years trying to block automated traffic.
Agentic commerce creates the opposite problem.
Some bots are now customers.
A merchant needs to distinguish:
- scraper;
- credential-stuffing bot;
- fraud automation;
- legitimate shopping agent;
- legitimate agent with valid payment authority.
Visa positions Trusted Agent Protocol as infrastructure for recognizing trusted agent-driven interactions and preventing legitimate autonomous commerce from being treated like malicious bot activity.
The economic value is obvious.
If merchant anti-bot systems reject valuable purchasing agents, merchants lose revenue.
If they blindly allow bots, fraud exposure increases.
KYA becomes part of conversion optimization.
Visa Intelligent Commerce6. The New Visa, Mastercard and Ant International KYA Framework
Know-Your-Agent Interoperability
The announcement on 10 September 2026 may prove more important than the initial technical detail suggests.
Visa, Mastercard and Ant International said they are collaborating on a shared Know-Your-Agent interoperability framework.
The goal is to let:
- card networks;
- digital wallets;
- agent platforms;
- online marketplaces;
recognize trusted agents across different payment ecosystems while retaining their own approval and risk processes.
The initiative is being pursued through BuildFin.ai, convened by the Monetary Authority of Singapore.
This resembles an important pattern from traditional finance.
Participants do not need to share one universal risk model.
They need enough interoperable identity and evidence to make their own risk decision.
That is a much more realistic goal.
7. AIP and AgentID: The Internet-Draft Layer
Several 2026 Internet-Drafts are explicitly trying to bind agent identity, delegation and actions together.
One Agent Identity Protocol proposal defines:
- a unique identity for each agent;
- a key pair;
- registration;
- signed outbound actions;
- policy enforcement.
Another AIP proposal defines Invocation-Bound Capability Tokens intended to carry:
- identity;
- authorization;
- scope constraints;
- delegation provenance.
A separate AgentID draft similarly proposes signed tokens containing agent identity, owner verification, capabilities and delegation-chain claims.
These ideas are strategically important because they address a problem that ordinary OAuth often does not fully solve:
multi-hop delegation.
Imagine:
Human → Portfolio Agent → Execution Agent → Exchange Tool
The exchange should ideally be able to determine not merely that the Execution Agent has a valid credential, but how that authority was derived.
However, Internet-Drafts are works in progress and should not be treated as adopted IETF standards.
The Multi-Hop Delegation Problem
Agent systems increasingly delegate work to other agents.
This creates chains such as:
CFO → Treasury Agent → FX Agent → Stablecoin Router → Exchange API
If every hop simply receives the original CFO's full authority, least privilege fails.
A safer chain should attenuate authority.
For example:
- CFO grants treasury agent $1 million daily cash-management authority;
- treasury agent delegates $200,000 FX authority;
- FX agent delegates a $50,000 execution instruction;
- router receives authority for one trade;
- exchange sees only the permissions necessary for that action.
Authority should generally get narrower as it moves away from the principal.
The DN Agent Trust Gap
The most dangerous system can be one where identity confidence is high but authority confidence is low.
Imagine a bank can prove with 100% cryptographic certainty that:
Agent X sent the payment request.
But nobody can establish:
who authorized Agent X to make that particular payment.
The identity is strong.
The action legitimacy is weak.
DN Agent Trust Gap Calculator
Score an agent architecture across identity, delegated authority, policy enforcement, revocation, evidence and reputation.
This calculator assesses architecture and configuration only. It is not an identity certification, cybersecurity audit, KYC determination, compliance opinion or guarantee that an agent will behave correctly.
KYA Is Not KYC for Robots
The phrase Know Your Agent naturally invites comparison with Know Your Customer.
There is overlap, especially where agents initiate regulated financial activity.
But the two problems are different.
| Question | KYC | KYA |
|---|---|---|
| Primary subject | Human or legal entity | Autonomous software actor |
| Who owns it? | Beneficial ownership where relevant | Principal, operator, developer or deploying organization |
| What may it do? | Often governed separately by product permissions | Core part of agent trust evaluation |
| Delegation | Authorized users / representatives | Potential multi-agent chains and tool delegation |
| Behavior | Transaction monitoring | Action monitoring + tool usage + transaction behavior |
| Revocation | Account access can be removed | Agent authority may need immediate machine-speed revocation |
| Reputation | Credit / fraud / compliance history | Task performance, delivery, validation and counterparty history |
| Liability | Usually attributable to known person/entity | Agent action must be traceable to responsible principal and mandate |
A regulated transaction may therefore require both.
The financial institution may need to know:
who the customer is
and:
which agent is acting for that customer under which authority.
An Agent Wallet Address Is Not an Identity
A blockchain address is useful.
It proves control of a signing key.
It does not automatically tell a counterparty:
- which software system controls it;
- who deployed the software;
- which person or entity owns it;
- what the agent is permitted to do;
- whether the wallet is compromised;
- whether the agent's capabilities are genuine.
This distinction becomes important as agents accumulate economic histories.
A wallet can be part of agent identity.
It should not be confused with the entire identity.
The Wallet Policy Is Part of KYA
The previous DN Agentic Wallet Security Index introduced Agent Blast Radius.
KYA adds another dimension.
A counterparty may want to know not only:
“Is this a legitimate agent?”
but:
“What constraints does this agent operate under?”
An agent with:
- $500 transaction cap;
- $2,000 daily limit;
- approved merchant list;
- eight-hour session expiry;
- human approval above threshold;
presents a different risk profile from an agent holding the same identity but possessing unlimited signing authority.
Reputation Could Become Machine Credit
Agent reputation becomes economically interesting when counterparties begin pricing transactions according to history.
A seller agent with:
- 10,000 validated deliveries;
- low dispute frequency;
- high uptime;
- independent validators;
- long-lived identity;
may be able to:
- charge more;
- receive larger mandates;
- require less collateral;
- win more RFQs;
- obtain credit.
At that point reputation stops being merely a review system.
It becomes a form of machine economic capital.
The Reputation Reset Attack
Consider an agent that accumulates poor feedback.
A human company may struggle to erase its corporate history.
A software operator may simply:
- retire Agent-104;
- create Agent-105;
- transfer functionality;
- begin with a clean reputation record.
That creates the reputation reset problem.
High-value markets may eventually need stronger links between:
- agent identity;
- operator identity;
- economic stake;
- organizational credentials;
- historical continuity.
Why NIST Is Treating Agent Identity as Infrastructure
NIST's 2026 work is significant because it frames agent identity as a broad cybersecurity problem rather than a crypto-specific problem.
The National Cybersecurity Center of Excellence is examining:
- agent identification;
- authorization;
- auditing;
- non-repudiation;
- controls around prompt injection;
- standards-based approaches to agent access.
NIST has separately warned that early agent deployments are repeating a familiar technology pattern:
features first, security later.
That is particularly dangerous when agents can:
- deploy code;
- send emails;
- modify systems;
- purchase products;
- move money.
Model Guardrails Are Not Identity Controls
A robust system separates:
- model reasoning;
- agent identity;
- principal identity;
- delegated authorization;
- policy enforcement;
- transaction signing;
- evidence.
The model may propose an action.
The security system decides whether that action is admissible.
The Ideal KYA Stack for Agentic Finance
The DN Minimum KYA Profile
Machine-readable trust data could eventually become as important as website metadata.
DN proposes that any consequential financial agent should be able to expose or provide, directly or through trusted infrastructure, a profile containing at least:
{
"agent_id": "persistent-agent-identifier",
"agent_provider": "responsible-provider",
"principal_type": "individual | company | dao | institution",
"principal_binding": "verified-reference",
"capabilities": [
"market-data",
"trade",
"payment"
],
"delegation": {
"scope": [
"BTC-USDC",
"trade-only"
],
"max_transaction_usd": 5000,
"max_daily_usd": 20000,
"expires_at": "ISO-8601 timestamp"
},
"policy_enforcement": "external-policy-system",
"revocation_endpoint": "verified-reference",
"reputation": {
"source": "portable-reputation-layer",
"independent_counterparties": true
},
"validation": [
"optional-attestation-reference"
],
"audit_evidence": "signed-action-log-reference"
}
This is a DN editorial reference model, not an official industry standard and not a recommendation to expose private or sensitive identity information publicly. Production systems should use privacy-preserving identifiers and disclose only what the relying party legitimately requires.
Privacy Is the Other Half of KYA
The obvious response to an identity problem is to collect more identity data.
That can create another problem.
A global machine economy should not require every agent to broadcast:
- its owner's legal identity;
- complete wallet holdings;
- private strategy;
- full negotiating limits;
- internal system architecture.
The correct model is likely to be selective proof.
A counterparty may need to know:
“This agent is operated by a verified institution authorized to transact up to this amount.”
It may not need to know every private detail about that institution.
Agent identity will therefore intersect with:
- verifiable credentials;
- selective disclosure;
- zero-knowledge proofs;
- privacy-preserving attestations.
The Rise of Machine Counterparty Risk
Once agents transact directly, counterparties need a machine equivalent of counterparty due diligence.
Before accepting a trade, a receiving agent may evaluate:
- identity age;
- operator quality;
- reputation;
- transaction history;
- validation history;
- economic stake;
- mandate strength;
- payment reliability;
- dispute history;
- software attestation;
- jurisdiction or institutional credentials.
These signals can become inputs into automated pricing.
A highly trusted agent might receive:
- better credit terms;
- lower collateral requirements;
- larger transaction limits;
- lower risk premiums;
- faster settlement.
Trust Scores Can Become Dangerous Too
Compressing agent trust into one number is convenient.
It is also risky.
A 96/100 trust score can hide:
- excellent payment history but weak cybersecurity;
- strong identity but no principal mandate;
- great reputation for API tasks but no history trading leveraged assets;
- thousands of reviews generated by related identities.
DN therefore favors dimensional trust over one universal score.
| Trust Dimension | Question |
|---|---|
| Identity Confidence | Do we know which autonomous actor this is? |
| Principal Confidence | Do we know who is responsible for the agent? |
| Authority Confidence | Was this exact action within delegated permission? |
| Capability Confidence | Can the agent actually perform the claimed task? |
| Reputation Confidence | Is historical feedback independent and economically meaningful? |
| Validation Confidence | Has a credible independent party verified relevant claims? |
| Operational Confidence | Is the agent currently functioning safely and reliably? |
Know Your Agent for Trading
A financial exchange receiving an autonomous order may eventually need more than an API key.
The ideal request could convey:
- authenticated account;
- authenticated agent identity;
- trade-only authority;
- permitted products;
- maximum order size;
- maximum leverage;
- mandate expiry;
- risk-policy result;
- client order ID;
- action signature.
This would let exchanges distinguish:
“the customer logged in”
from:
“Agent 47 was specifically permitted to make this trade under this policy.”
Know Your Agent for Payments
A payment agent may need a different KYA profile.
Relevant attributes include:
- merchant restrictions;
- currency;
- transaction maximum;
- session maximum;
- credential issuer;
- purchase mandate;
- expiration;
- human step-up rules.
This is why Visa, Mastercard, AP2 and other payment frameworks focus heavily on intent and delegated credentials rather than generalized agent reputation alone.
Know Your Agent for Open Agent Markets
An agent buying compute from an unknown autonomous seller faces another problem.
There may be no bank, card network or enterprise IAM provider mediating trust.
That is where:
- portable identity;
- A2A discovery;
- onchain reputation;
- validation;
- payment receipts;
become more important.
Open markets need trust infrastructure precisely because they lack pre-existing organizational relationships.
India Is Already Exploring an Agent Registry for Payments
The trend is not confined to card networks or crypto.
India's payments ecosystem is reportedly developing an agent registry as part of work around agentic UPI payments.
The proposed direction includes:
- approved-agent registration;
- identity checks;
- spending controls;
- liability frameworks;
- monitoring.
The significance is structural.
Major payment systems are beginning to treat AI agents as actors that need their own recognition and control plane.
DN KYA Methodology
Version 1.0 evaluates each component according to its stated trust role. The technologies are deliberately not treated as interchangeable products.
| Dimension | Weight | DN Question |
|---|---|---|
| Cryptographic Integrity | 20 | Can identity, metadata, mandates or decisions be verified rather than merely asserted? |
| Agent Specificity | 15 | Was the system explicitly designed for autonomous software actors? |
| Authority / Policy Coverage | 20 | Does the system help establish or enforce what an agent may do? |
| Interoperability | 15 | Can independently built systems use a common representation or decision interface? |
| Auditability | 10 | Can the action and trust evidence be reconstructed afterward? |
| Trust / Validation Depth | 10 | Does the system support reputation, validation or reliance beyond self-assertion? |
| Specification & Deployment Maturity | 10 | Is the infrastructure standardized, deployed and sufficiently documented today? |
DN does not award maturity points to a proposal merely because its design appears promising.
Final specifications, reproducible implementations and real deployment carry more weight than roadmaps.
What Would Prove the KYA Thesis Wrong?
The market may consolidate around a few large agent platforms.
If nearly all consequential agents operate inside Google, Microsoft, OpenAI, Amazon, Visa, Mastercard or large financial institutions, identity could remain primarily platform-local.
Existing OAuth, service-account and enterprise IAM systems might prove sufficient for most use cases.
Open reputation may also fail to become important if agent marketplaces remain closed.
And many high-value actions may continue requiring direct human approval.
But the more agents cross organizational boundaries, subcontract to other agents and move economic value independently, the harder it becomes to rely entirely on local accounts and implied trust.
The Biggest Missing Standard: Reliance
Identity systems can prove facts.
Authorization systems can return decisions.
Reputation systems can publish history.
But high-value finance eventually asks another question:
Who is willing to rely on this evidence and accept liability when it fails?
That is where technical standards intersect with:
- contracts;
- insurance;
- regulation;
- payment rules;
- institutional risk management.
A cryptographically perfect identity does not by itself determine who reimburses a customer after an unauthorized $100,000 agent transaction.
The trust stack therefore ends not in cryptography, but in economic accountability.
Identity Is Only One Layer of Agentic Finance
After establishing who an agent is and what it is allowed to do, the next questions are where it holds capital, where it trades and how safely it settles.
Agentic Wallet Security Index Best Wallets for AI Agents Best Crypto Platforms for AI Agents When Bots Negotiate Agent Checkout Reliability IndexSome related DN decision pages may contain separately disclosed commercial relationships. No affiliate relationship determines conclusions in this KYA Index.
Frequently Asked Questions
What does Know Your Agent mean?
Know Your Agent, or KYA, describes the emerging identity, authorization and trust infrastructure used to determine which autonomous AI agent is acting, who it represents, what authority it has and whether a relying party should trust the action.
Is KYA the same as KYC?
No. KYC identifies a human customer or legal entity. KYA focuses on the autonomous software actor, its principal, delegated authority, permissions and action evidence. A regulated financial transaction may require both KYC and KYA.
What is ERC-8004?
ERC-8004 is a draft Ethereum standard for open agent economies. It proposes Identity, Reputation and Validation Registries so agents can discover one another and evaluate trust across organizational boundaries.
What is an A2A Agent Card?
An Agent Card is a machine-readable document in the Agent2Agent protocol describing an agent's provider, endpoints, capabilities, authentication requirements and skills. A2A 1.0 allows Agent Cards to carry JSON Web Signatures so clients can verify their integrity and origin.
What is OpenID AuthZEN?
AuthZEN is an OpenID Foundation initiative for interoperable authorization. Its Authorization API standardizes how Policy Enforcement Points request authorization decisions from Policy Decision Points. Agent-focused work is extending this model to dynamic tool calls and approval flows.
What is the DN Agent Trust Gap?
The DN Agent Trust Gap measures the difference between confidence that a system has identified the correct agent and confidence that the agent possessed valid authority for the specific action attempted.
What is the DN Agent Authority Chain?
The DN Agent Authority Chain is a seven-link model connecting principal, agent, mandate, policy, action, settlement and evidence. It is designed to show where accountability can break during autonomous financial activity.
What is DN Reputation Purity?
DN Reputation Purity is the proportion of an agent's reputation that can be attributed to sufficiently independent, identifiable and verifiable counterparties rather than Sybil identities, self-dealing, circular transactions or unverifiable feedback.
Is a crypto wallet address enough to identify an AI agent?
No. A wallet address proves control of a cryptographic key but does not automatically identify the software agent, its operator, principal, delegated mandate or permitted scope.
Why does KYA matter for agentic finance?
Agents that trade, pay, borrow, lend or manage treasury capital need more than credentials. Counterparties need ways to establish identity, delegated authority, transaction limits, revocation, reputation and accountability before allowing autonomous software to move meaningful value.
Primary Sources
- Reuters: Visa, Mastercard and Ant International Know-Your-Agent Initiative
- NIST NCCoE: Software and AI Agent Identity and Authorization
- NIST: Why Agentic AI Needs a Strong Identity Foundation
- OpenID Authorization API 1.0 Final Specification
- OpenID AuthZEN: Authorization in the Agent Era
- A2A Protocol 1.0 Specification
- ERC-8004: Trustless Agents
- Ethereum.org: AI Agents and ERC-8004
- Mastercard Verifiable Intent
- Visa Intelligent Commerce and Trusted Agent Protocol
- IETF Internet-Draft: Agent Identity Protocol and Policy Enforcement
- IETF Internet-Draft: Verifiable Delegation for AI Agent Systems
- Reuters: India's Proposed AI-Agent Registry for Agentic Payments
Commercial Disclosure: This is protocol and infrastructure research. The KYA components and standards in the index are not ranked according to commercial relationships. Related DN wallet and trading-platform pages may contain separately disclosed partner links.
Standards Status: Standards and proposals differ materially in maturity. OpenID Authorization API 1.0 and A2A 1.0 have reached formal published specification milestones, while ERC-8004 and several Agent Identity Protocol proposals remain draft or work-in-progress standards. The Visa, Mastercard and Ant International KYA interoperability initiative was newly announced in September 2026 and remains under development.
Security Disclaimer: Cryptographic identity, reputation, authorization and policy systems reduce specific risks but do not prove that an AI model will behave correctly or that an action is economically safe. Agentic systems remain exposed to software, credential, prompt-injection, counterparty, model and operational risks.
Regulatory Disclaimer: KYA does not replace legal KYC, AML, sanctions, licensing, consumer-protection or market-conduct obligations where those requirements apply. Nothing on this page constitutes legal, financial, cybersecurity or compliance advice.






