Skip to main content
Skip to content
Agentic Finance

Wallets, DIDs, Agent Cards and ERC-8004: The AI Agent Identity Stack for 2027

A definitive map of AI-agent identity across wallets, DIDs, verifiable credentials, A2A Agent Cards, MCP authorization, workload identity and draft ERC-8004 registries.

AI agent identity stack connecting wallets, DIDs, Agent Cards, credentials and ERC-8004 registries
Reading options: audio, text size & sections
Decentralised News Research · Agentic Finance

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.
Recommended Identity Stack
2 layers

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:

  1. Persistent identifier for continuity.
  2. Verified controller showing who owns or operates it.
  3. Cryptographic authentication proving control of current credentials.
  4. Independent authorization limiting actions.
  5. Portable credentials for externally issued claims.
  6. Version history showing material changes.
  7. Reputation provenance rather than an opaque score.
  8. 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

W3C Verifiable Credentials 2.0
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.

Open DN Pathfinder

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

Get the most talked about stories directly in your inbox

Join the Decentralised News briefing for independent crypto, DeFi and AI analysis. No spam, unsubscribe anytime.