The agentic economy has an identity problem. An AI agent may have a wallet, API key, OAuth token, enterprise workload identity, A2A Agent Card, decentralized identifier and blockchain registration at the same time. None of these alone answers the full question: who operates this agent, what authority does it have, what can it prove, and should another machine trust it?
Framework: DN Agent Identity Map 1.0 · Last verified: 18 November 2026 · Proprietary tool: DN Agent Identity Architecture Selector
What Matters
AI agents will need more than usernames. Production identity must separate at least five questions: identifier, controller, authorization, credentials and reputation. Enterprise agents may rely on workload identity and OAuth. Open-network agents may add wallets, DIDs, verifiable credentials or registries such as draft ERC-8004. The winning architecture is likely layered rather than universal.
DN Evidence Block
6+
major agent identity architectures
5
identity questions DN separates
4
trust domains: platform, enterprise, web and blockchain
1
critical rule: identity is not authorization
Evidence base: W3C Verifiable Credentials 2.0 became a Recommendation in May 2025. DID 1.1 reached Candidate Recommendation in March 2026, while DID Resolution advanced again in October 2026. SPIFFE remains a production standard for workload identity. A2A uses Agent Cards for discovery and authentication requirements. MCP’s July 2026 specification substantially hardened authorization. Ethereum’s ERC-8004 remains a draft proposal for portable agent identity, reputation and validation.
The Signal: The Internet Was Built for Human Accounts and Server Accounts
The next internet may contain billions of software actors that discover services, negotiate, buy data, move money and collaborate without a human manually initiating every interaction.
Today’s identity infrastructure was not originally designed for that world.
Humans typically authenticate through passwords, passkeys, biometrics, OAuth accounts or government-issued credentials.
Software workloads use API keys, service accounts, certificates and cloud identities.
Crypto adds public-private key pairs and wallets.
Agent protocols add machine-readable cards and capability descriptions.
Decentralized identity adds DIDs and verifiable credentials.
Emerging agent registries add persistent identity and reputation.
These systems overlap, but they solve different problems.
DN thesis: There will probably be no single universal “AI passport.” The durable architecture is more likely to be an identity stack in which different layers answer different trust questions.
The Five Questions Every Agent Identity System Must Answer
1
Who Is It?
A stable identifier that distinguishes one agent or workload from another.
2
Who Controls It?
A verifiable relationship to the company, user, wallet, developer or organization responsible for the agent.
3
What May It Do?
Authorization scopes, permissions, financial limits and delegated authority.
4
What Can It Prove?
Credentials, attestations, certificates, ownership proofs and capabilities.
5
Should You Trust It?
Reputation, validation history, provenance, audit history and evidence of successful work.
Identity Is Not Authorization
This distinction is foundational.
A cryptographic identifier can prove that the same entity is interacting again.
It does not prove that the entity should be allowed to transfer money, read confidential documents or modify production infrastructure.
Likewise, an OAuth token may authorize an application to access a resource without creating a permanent globally portable identity for the agent.
DN Identity Rule: Authentication answers “who is calling?” Authorization answers “what may this caller do?” Reputation answers “should another party rely on it?” These should not be collapsed into one score.
The Global AI Agent Identity Map
| Identity layer | Best suited to | Strength | Main limitation |
|---|---|---|---|
| Platform Account | Agents operating inside one SaaS or marketplace | Simple onboarding and centralized recovery | Limited portability outside platform |
| API / OAuth Identity | Agents accessing web services | Mature authorization and scopes | Usually service-specific rather than globally portable |
| Workload Identity | Enterprise and cloud agents | Strong machine authentication and short-lived credentials | Primarily infrastructure identity, not public reputation |
| Wallet Identity | Agents transacting with crypto or signing messages | Portable cryptographic control and payments | A wallet address does not prove owner, capability or trustworthiness |
| DID + Verifiable Credentials | Portable cross-domain identity and attestations | Machine-verifiable credentials without one central identity provider | Trust still depends on issuer quality and ecosystem adoption |
| Agent Registry | Open agent discovery and portable reputation | Persistent identifier plus public metadata | Registry presence does not prove safe or functional behavior |
| Agent Card | A2A discovery and interaction | Describes identity, skills, endpoints and auth requirements | Self-description is not equivalent to independent verification |
Choose an Agent Identity Architecture
DN Agent Identity Architecture Selector
Select the environment and trust requirements. The tool recommends an identity stack rather than forcing every agent into the same identity model.
The dominant trust environment.
Portable identity requires different primitives from a local service account.
Examples: licensed provider, approved supplier, insured operator.
Financial action raises the importance of signing identity and bounded authorization.
Open discovery increases the need for public metadata and reputation.
Portable trust requires more than authentication.
Enterprise Workload Stack
A machine identity plus scoped authorization is usually sufficient for a private enterprise environment.
Recommended components
- Workload identity
- OAuth / policy authorization
1. Platform Identity: The Simplest Agent Passport
The easiest way to identify an agent is through the platform that hosts it.
The platform creates an account, controls login, stores metadata and decides which permissions the agent receives.
This model works well when every interaction remains inside a trusted environment.
Its weakness appears when the agent leaves.
A five-star reputation on one marketplace may have no meaning elsewhere.
The agent’s identity therefore belongs partly to the platform rather than fully to the agent or its operator.
2. OAuth and API Identity: Mature but Application-Specific
OAuth has become one of the most important authorization foundations for agents connecting to external services.
It lets a user or organization grant limited access without handing the agent a master password.
Scopes can constrain access to particular actions or datasets.
The July 2026 MCP specification further hardened its authorization architecture and aligned it more closely with modern OAuth and OpenID Connect deployment practices.
This is important for agentic systems because tool connectivity without scoped authorization creates excessive agency.
But OAuth typically answers a local question:
“What is this client allowed to do with this service?”
It does not necessarily create a globally portable identity.
3. Workload Identity: The Enterprise Agent Layer
Enterprise infrastructure has already spent years solving a problem remarkably similar to agent identity.
How can a software workload prove what it is without storing long-lived passwords?
SPIFFE addresses this through machine identities known as SPIFFE IDs and cryptographically verifiable SVIDs.
A workload can obtain short-lived X.509 credentials and use them to authenticate to another service.
That makes SPIFFE especially relevant to internal enterprise agents.
A finance agent could have a different machine identity from a customer-service agent even if both run on the same infrastructure.
DN implication: Many enterprise AI agents may ultimately look more like privileged workloads than like digital humans.
4. Wallet Identity: Identity That Can Hold and Move Value
Crypto adds something traditional software identity does not naturally provide:
A machine can possess a cryptographic address capable of receiving assets, signing messages and authorizing transactions.
That makes wallets attractive as identifiers in an autonomous economy.
But wallet identity is easy to overinterpret.
A wallet proves control of a key.
It does not automatically establish:
- who ultimately owns the agent;
- whether the agent is authorized by a company;
- whether its claimed skills are real;
- whether its previous work was competent;
- whether it is insured;
- whether it complies with a jurisdiction’s rules.
A wallet address is an identifier and signing authority. It is not a complete identity system.
5. Decentralized Identifiers: Portable Identity Without One Platform
W3C Decentralized Identifiers are designed to create identifiers under the control of the DID controller rather than a traditional centralized identity provider.
DIDs resolve to DID Documents containing information such as public keys and service endpoints.
DID 1.1 reached Candidate Recommendation in March 2026.
DID Resolution, which specifies how a DID is resolved into its associated document and metadata, continued progressing through the standards process in October 2026.
This model is potentially useful for agents that need an identity capable of persisting across multiple platforms.
6. Verifiable Credentials: Proving Attributes About the Agent
Identity alone is rarely enough.
A buyer may need to know whether an agent represents an approved company.
A regulated platform may need evidence that an agent has authority to perform a specific function.
A marketplace may want proof that an agent passed a security audit.
W3C Verifiable Credentials provide a machine-readable way for issuers to make cryptographically verifiable claims.
The Verifiable Credentials 2.0 family became a W3C Recommendation in May 2025.
OpenID for Verifiable Credential Issuance 1.0 became an OpenID Final Specification in September 2025, providing a standardized protocol for issuing such credentials.
DN identity insight: DIDs can answer “which identity?” while Verifiable Credentials can answer “what has a trusted issuer said about this identity?”
The Agent Credential Economy
Once credentials become machine-readable, agents could carry attestations such as:
- verified operator;
- approved corporate agent;
- security audit passed;
- licensed financial provider;
- approved supplier;
- insured up to a stated amount;
- authorized spending limit;
- validated model version;
- verified training qualification;
- jurisdiction eligibility.
This could create a market for machine-verifiable trust.
The crucial question becomes who issuers are and why counterparties should trust them.
7. A2A Agent Cards: Identity Meets Discovery
The Agent2Agent protocol uses an Agent Card as a machine-readable description of an A2A server.
The card can describe:
- name;
- provider;
- service endpoint;
- supported capabilities;
- authentication requirements;
- skills.
A2A also allows Agent Cards to be digitally signed using JWS.
That creates an important bridge between discovery and identity.
But a signed Agent Card primarily proves that the advertised card has not been altered and is associated with a signing authority.
It does not independently prove every claim made inside the card.
Discovery tells you an agent exists. Authentication tells you who you are talking to. Validation tells you whether its claims deserve trust.
8. ERC-8004: A Proposed On-Chain Agent Identity Layer
ERC-8004 is one of the clearest attempts to build identity and trust primitives specifically for open agent economies.
As of October 2026, ERC-8004 remains a draft Ethereum standard and should not be described as finalized.
The proposal defines three registries:
Identity Registry
Provides agents with portable on-chain identifiers and registration metadata.
Reputation Registry
Provides a common interface for publishing feedback associated with registered agents.
Validation Registry
Allows agent work to be checked by external validation mechanisms.
The identity registry is based on ERC-721 and allows registration metadata to point to endpoints including A2A, MCP, ENS, DIDs and wallets.
This is significant because it treats agent identity not as a replacement for these systems but as a layer connecting them.
The Important Limitation of ERC-8004
Registration does not equal verification.
The ERC itself acknowledges that cryptographic registration cannot guarantee that advertised capabilities actually work or are non-malicious.
That is why reputation and validation are separate.
DN rule: Never treat “registered agent” as synonymous with “trusted agent.”
The Agent Identity Stack
DN proposes six functional layers.
| Layer | Question | Possible technology |
|---|---|---|
| Identifier | Which agent is this? | Account ID, SPIFFE ID, DID, wallet address, ERC-8004 agent ID |
| Controller | Who controls the identity? | Organization account, key ownership, DID controller, wallet owner |
| Authentication | Can it prove control? | TLS certificate, signature, SVID, OAuth client authentication |
| Authorization | What may it do? | OAuth scopes, IAM policy, wallet permissions, policy engine |
| Credentials | What trusted claims exist about it? | Verifiable Credentials, certificates, attestations |
| Reputation | How has it behaved? | Platform reviews, registry history, validated task outcomes |
The Ownership Problem
One of the least solved agent identity questions is ownership.
Suppose an agent has a valid cryptographic identity.
Who is responsible for it?
Possibilities include:
- the user who launched it;
- the company deploying it;
- the developer who built it;
- the platform hosting it;
- a DAO;
- a smart contract;
- another autonomous agent.
Identity systems need to distinguish the agent from the legal or economic principal behind it.
DN Ownership Chain: Agent ID → Operator → Principal → Delegated Authority → Current Action.
That chain may become as important to the agentic economy as know-your-customer infrastructure is to today’s financial system.
Proof of Agency
An agent should ideally be able to prove not only who it is but that it has authority to act for someone else.
Imagine a procurement agent ordering $15,000 of equipment.
A supplier may need proof that:
- the agent represents Company A;
- Company A authorized the agent;
- the authorization has not expired;
- the order remains within the agent’s spending limit;
- the supplier is an approved counterparty.
That is different from verifying the agent’s identity.
DN calls the full chain Proof of Agency.
The Identity Continuity Problem
Agents can change model providers.
They can migrate between clouds.
They can rotate cryptographic keys.
They can add tools.
They can be upgraded.
At what point does an upgraded agent become a different agent?
This becomes important if reputation is portable.
A system should not be able to accumulate trust under one configuration and then silently replace its core model, owner or permissions while preserving the same reputation without disclosure.
DN Identity Continuity Test
| Change | Same identity? | DN recommended treatment |
|---|---|---|
| Key rotation | Usually yes | Preserve identity with verifiable rotation history |
| Endpoint migration | Usually yes | Update endpoint with authenticated continuity proof |
| Minor software update | Usually yes | Record version history |
| Model provider change | Conditional | Disclose major behavioral architecture change |
| Ownership transfer | High significance | Explicit controller change and reputation disclosure |
| Permissions dramatically expanded | High significance | Reassess trust and authority |
| Entire operating stack replaced | Potentially new agent | Do not assume historical reputation transfers automatically |
Identity Without Reputation Creates Sybil Problems
Cryptographic identity is cheap.
An attacker may create thousands of agents.
That makes identity alone insufficient for open marketplaces.
ERC-8004 explicitly notes the possibility of Sybil attacks against reputation systems.
A useful trust layer therefore needs to evaluate not only the agent receiving feedback but also:
- who issued the feedback;
- whether the reviewer has economic exposure;
- whether the interaction actually happened;
- whether multiple identities belong to one actor;
- whether feedback can be purchased;
- whether work was independently validated.
The Reputation Portability Paradox
Portable reputation sounds universally beneficial.
It can also transport manipulation.
If an attacker manufactures a strong reputation in a weak environment and imports it into a high-value marketplace, portability makes the attack more powerful.
Reputation should be portable only with provenance.
A score should reveal:
- where it originated;
- what tasks generated it;
- who provided feedback;
- when it was earned;
- which agent version earned it;
- whether outcomes were validated.
Agent Identity and Financial Risk
Identity becomes far more consequential when an agent can move money.
A payment recipient may need to know whether:
- the agent is genuine;
- the agent represents the stated payer;
- its authority remains valid;
- the transaction remains within its limit;
- the destination is permitted.
This is why agent wallets, identity and authorization cannot be treated as separate editorial beats.
They are converging into one financial trust stack.
The Machine Counterparty Problem
Human commerce relies heavily on institutions that stand behind identities.
Banks know account holders.
Businesses know suppliers.
Employees operate under employment contracts.
Payment networks can identify merchants.
What happens when one agent buys a service from another agent neither owner has previously encountered?
The counterparty relationship may need to be established in milliseconds.
That requires identity to become machine-readable, cryptographically verifiable and economically interpretable.
The DN Machine Counterparty File
DN proposes that high-value agents eventually expose a machine-readable trust file containing:
- persistent agent identifier;
- operator identity;
- principal organization;
- public endpoints;
- supported protocols;
- current software/model version;
- credentials;
- permissions or disclosed authority class;
- reputation sources;
- validation history;
- insurance where applicable;
- incident history;
- last identity update.
This is conceptually similar to the DN Agent Passport idea, but designed specifically for machine-to-machine counterparty assessment.
How MCP Fits Into the Identity Map
MCP is primarily a protocol for connecting AI applications with tools, data and workflows.
Its authorization architecture increasingly relies on established OAuth and OpenID Connect patterns.
That makes MCP highly relevant to the authorization layer of agent identity.
It should not automatically be treated as a portable agent identity system.
An MCP server can authenticate and authorize a client without providing a universal identity or portable reputation for the underlying agent.
How A2A Fits Into the Identity Map
A2A sits closer to agent-level interaction.
Its Agent Card describes the remote agent’s identity, provider, capabilities and authentication requirements.
The protocol also supports signed Agent Cards.
This makes A2A an important identity presentation and discovery mechanism.
But A2A deliberately relies on established web security and enterprise authentication practices rather than inventing a complete global trust system.
How ERC-8004 Fits Into the Identity Map
ERC-8004 addresses a different problem:
How can independent agents discover and establish trust across organizational boundaries where no common platform already exists?
Its proposed on-chain identity, reputation and validation registries make it potentially complementary to A2A and MCP rather than competitive with them.
An ERC-8004 registration file can point to A2A endpoints, MCP endpoints, DIDs, ENS names and wallets.
That is a useful architectural clue.
The emerging stack may be composable: registry for discovery, Agent Card for capabilities, OAuth for authorization, wallet for payment, DID/VC for credentials, and independent reputation for trust.
What Should an Enterprise Use?
Most enterprises do not need a blockchain identity for every internal agent.
A private internal agent may be better served by:
- enterprise workload identity;
- short-lived credentials;
- OAuth or IAM authorization;
- centralized audit logs;
- explicit ownership;
- internal policy enforcement.
Open identity becomes more useful when agents interact across organizational boundaries.
What Should a Public Agent Use?
A public service agent has different needs.
It may require:
- public discovery;
- a signed capability description;
- provider verification;
- authentication;
- cross-platform credentials;
- portable reputation.
That can justify a layered combination of A2A, web identity, verifiable credentials or decentralized identifiers.
What Should a Crypto-Native Agent Use?
A crypto-native agent may need an even broader stack:
- wallet or smart-account identity;
- transaction permissions;
- A2A or MCP endpoints;
- public registry identity;
- reputation or validation;
- domain ownership proof;
- machine-readable authorization limits.
The key is not to confuse the wallet with the whole identity.
DN Agent Identity Architecture Matrix
| Use case | Primary identity | Authorization | Portable credential | Reputation |
|---|---|---|---|---|
| Internal enterprise agent | SPIFFE / service identity | IAM / OAuth | Optional | Internal logs |
| SaaS automation agent | Platform / OAuth client | OAuth scopes | Optional VC | Platform history |
| Public A2A agent | Agent Card + web domain | A2A security scheme | VC / DID optional | Registry or marketplace |
| Crypto trading agent | Wallet / smart account | Wallet policy | VC / registry metadata | Task history / registry |
| Open autonomous merchant | Portable agent ID | Payment and tool policies | VC + operator attestation | Portable reputation |
| Regulated financial agent | Enterprise + cryptographic identity | Strict delegated authority | Regulatory / corporate credentials | Audited operational history |
The Identity Risk Ladder
| Level | Identity evidence | Appropriate trust |
|---|---|---|
| Level 0 | Self-declared name only | Minimal |
| Level 1 | Verified domain or platform account | Low |
| Level 2 | Cryptographic identity | Identity verified |
| Level 3 | Verified controller / operator relationship | Accountable |
| Level 4 | External credentials or attestations | Credentialed |
| Level 5 | Validated performance + provenance-rich reputation | Evidence-backed trust |
Identity Must Be Revocable
Permanent identifiers can be useful.
Permanent credentials are often dangerous.
Agents change ownership, lose keys, become compromised and receive new permissions.
A production identity system therefore needs:
- key rotation;
- credential expiration;
- revocation;
- controller updates;
- version history;
- incident status.
The strongest identity systems preserve continuity while allowing authority to change.
The Privacy Problem
Public identity can improve accountability while creating surveillance.
If every action by every agent maps permanently to one public identifier, observers may reconstruct:
- commercial relationships;
- purchasing behavior;
- customer activity;
- business strategy;
- financial positions;
- internal workflows.
The future identity stack therefore needs selective disclosure.
A counterparty may need proof that an agent is authorized to spend up to a certain amount without learning the organization’s entire treasury policy.
Verifiable credential systems are particularly relevant here because they can support claims rather than requiring all underlying identity data to be public.
The Agent Identity Attack Surface
Identity itself becomes a target once agents possess economic authority.
Attackers may attempt to:
- steal signing keys;
- impersonate agents;
- clone Agent Cards;
- hijack domains;
- forge credentials;
- poison reputation;
- take over dormant identities;
- inherit reputation after an ownership transfer;
- register lookalike agents;
- trick counterparties into granting excessive authorization.
The DN Agent Identity Security Rule
The stronger the authority associated with an identity, the stronger the proof, key protection, revocation and provenance requirements should become.
An agent reading public webpages does not need the same identity assurance as an agent settling $1 million of transactions.
Identity Assurance Should Scale With Value at Risk
This principle also appears in ERC-8004’s design philosophy.
Its trust model is explicitly intended to support different levels of assurance depending on the value at risk.
That is likely the right economic direction.
Low-value interactions should not require expensive identity ceremonies.
High-value interactions should not rely on self-declared metadata.
The Emerging Machine KYC Layer
Know Your Customer was designed around people and organizations.
The agent economy may need an adjacent concept:
Know Your Agent: identify the software actor, verify its principal, establish its authority and determine what evidence supports trusting its actions.
This does not necessarily mean subjecting software to human KYC.
It means creating a machine-native chain of accountability.
The Global Identity Fragmentation Problem
Different ecosystems are likely to choose different identity primitives.
Enterprises may prefer certificates and workload identity.
Crypto systems may prefer wallets and public registries.
Governments may issue verifiable credentials.
A2A environments may use Agent Cards.
MCP services may rely heavily on OAuth.
This creates an interoperability problem.
The successful identity layer may therefore be the one that can map between identities rather than replace all of them.
The DN Agent Identity Translation Layer
DN proposes treating identity mapping as a graph.
One agent could legitimately have:
Agent Card ↔ Domain ↔ DID ↔ Wallet ↔ SPIFFE ID ↔ Corporate Principal ↔ Verifiable Credentials ↔ Registry ID
The job of an identity translation layer is to establish which of these identifiers represent the same underlying agent or operating principal.
This may become a major infrastructure category in its own right.
Where the Market Is Likely Going
DN expects agent identity to develop in three phases.
Phase 1: Platform Identity
Agents inherit identity from cloud providers, applications and marketplaces.
Phase 2: Portable Identity
Agents carry verifiable identifiers, wallets and credentials across platforms.
Phase 3: Machine Trust Markets
Counterparties price agents according to identity assurance, reputation, validation, insurance and authority.
The Financial Consequence: Identity Becomes Credit Infrastructure
Once autonomous agents transact independently, trustworthy identity becomes economically valuable.
An agent with verified ownership, reliable payment history and validated task completion may eventually obtain:
- larger payment limits;
- supplier credit;
- lower collateral requirements;
- cheaper insurance;
- access to higher-value jobs;
- faster settlement;
- preferred marketplace ranking.
That creates a bridge from identity into agent credit.
Identity may therefore become one of the foundations of machine capital markets.
The DN Agent Identity Architecture
For high-value agents, DN’s preferred conceptual stack is:
- Persistent identifier for continuity.
- Verified controller showing who owns or operates it.
- Cryptographic authentication proving control of current credentials.
- Independent authorization limiting actions.
- Portable credentials for externally issued claims.
- Version history showing material changes.
- Reputation provenance rather than an opaque score.
- Revocation for compromised or retired agents.
DN Methodology
Framework: DN Global Agent Identity Map 1.0
Objective: Classify the major technical approaches available for identifying, authenticating, authorizing and assessing autonomous software agents.
Identity categories examined:
- platform accounts;
- API and OAuth identities;
- enterprise workload identities;
- cryptographic wallets;
- decentralized identifiers;
- verifiable credentials;
- Agent Cards;
- agent registries.
Core distinction: DN separates identifier, controller, authentication, authorization, credentials and reputation rather than treating “identity” as one function.
Evidence boundary: Standards status is reported according to primary documentation current to 18 November 2026. ERC-8004 remains a draft and is treated as an emerging architecture rather than a finalized standard.
Update cadence: Quarterly review, with immediate updates for major changes to A2A, MCP, W3C DID/VC, OpenID credential standards or agent-registry standards.
Commercial independence: Commercial relationships do not determine inclusion, architecture recommendations or conclusions.
Falsification test: The DN layered-identity thesis should be revised if one architecture demonstrates broad adoption while successfully providing portable identity, delegated authorization, external credentials, revocation and reputation across enterprise, web and blockchain environments without relying on complementary identity layers.
Limitations
Agent identity remains an emerging field.
Standards differ in maturity, adoption and purpose.
A technically valid identity does not guarantee safe behavior, legal accountability or trustworthy outcomes.
The framework also does not determine the legal status of autonomous agents in individual jurisdictions.
Identity architecture should therefore be evaluated together with authorization, security, privacy, governance and operational risk.
Primary Sources
Recommendation family for cryptographically secure, machine-verifiable credentials.
W3C Verifiable Credentials 2.0
W3C Decentralized Identifiers
DID 1.1 Candidate Recommendation and DID Resolution work defining portable decentralized identifiers and resolution.
W3C DID specifications
OpenID for Verifiable Credential Issuance 1.0
Final OpenID specification for standardized issuance of verifiable credentials.
OpenID4VCI 1.0
SPIFFE
Open standards for portable workload identity using SPIFFE IDs and SVIDs.
SPIFFE Standard
A2A Protocol
Agent Cards, authentication requirements, signed Agent Cards and agent discovery.
A2A Agent Discovery
Model Context Protocol
The July 2026 specification includes substantial authorization hardening and closer alignment with OAuth and OpenID Connect deployments.
MCP 2026-07-28
ERC-8004: Trustless Agents
Draft Ethereum proposal for agent identity, reputation and validation registries.
ERC-8004
Building for the Agentic Economy?
Use DN Pathfinder to compare the infrastructure route that fits what your agent actually needs to discover, authenticate, transact and operate.
Frequently Asked Questions
What is AI agent identity?
AI agent identity is the set of technical mechanisms used to distinguish an autonomous software agent, prove control of that identity, connect it to an operator or principal and determine what authority or credentials it possesses.
Does an AI agent need its own identity?
Agents performing consequential actions generally benefit from a distinct machine identity rather than sharing human credentials because this improves authorization, auditability, revocation and accountability.
Is a crypto wallet an AI agent identity?
A wallet can provide a persistent cryptographic identifier and signing authority, but it does not by itself prove who operates the agent, what it is authorized to do or whether it is trustworthy.
What is a DID?
A decentralized identifier is a W3C-standardized identifier designed to be controlled by its controller rather than dependent on a traditional centralized identity provider. DIDs can resolve to documents containing public keys and service information.
What are Verifiable Credentials?
Verifiable Credentials are cryptographically secured claims issued by one party about a subject and designed to be verified by another party. They can potentially allow agents to prove attributes such as organizational affiliation or authorization.
What is an A2A Agent Card?
An A2A Agent Card is a machine-readable document describing an A2A agent’s identity, provider, service endpoint, capabilities, skills and authentication requirements. Agent Cards may also be digitally signed.
What is ERC-8004?
ERC-8004 is a draft Ethereum proposal for trustless agents that defines identity, reputation and validation registries intended to help agents discover and establish trust across organizational boundaries.
Is ERC-8004 finalized?
No. As of 18 November 2026, ERC-8004 is still identified as a Draft Standards Track ERC and should not be described as a finalized Ethereum standard.
What is workload identity?
Workload identity gives software processes cryptographically verifiable machine identities. SPIFFE is one example, using SPIFFE IDs and short-lived verifiable identity documents known as SVIDs.
What is the difference between agent identity and authorization?
Identity establishes which agent is acting. Authorization determines what that agent is permitted to do. A verified identity should not automatically imply unrestricted permissions.
What is Know Your Agent?
Know Your Agent is a machine-native trust concept in which a counterparty identifies the software agent, verifies its operator or principal, establishes its delegated authority and evaluates evidence supporting trust in its actions.
Disclosure
Decentralised News develops independent research frameworks, indices, benchmarks and decision tools covering AI, crypto and agentic finance. Some Decentralised News pages may contain affiliate or commercial relationships. These relationships do not determine inclusion, methodology or editorial conclusions. The DN Global Agent Identity Map is an analytical framework and does not constitute legal, cybersecurity or financial advice.
Related reading:
AI Agent Payment Security: Eight Controls Every System Needs
The Best AI Agent Runtimes of 2027: OpenAI vs Google vs AWS vs Microsoft
How to Verify an AI Trading Bot Before Risking Any Money
AI Context Efficiency 2027: Useful Outcomes per Token
AI Model Routing 2027: Does It Save Money Without Losing Quality?
The Agentic Treasury Benchmark: Payments, Stablecoins and Financial Control