1,000,000 free RPC requestsJust a wallet, via x402.
Start buildingERC-8004: A Developer’s Guide to Trustless AI Agent Identity
ERC-8004 is Ethereum's identity standard for AI agents. Learn how its onchain registries enable discovery, reputation, and trust.

March 4, 2026 — 7 min read

AI agents aren’t headline-worthy anymore just because they can act. That part is becoming expected.
Today, an AI agent can call APIs, communicate with other agents, access tools, make payments, and coordinate workflows.
In many ways, they already behave like digital workers.
But there's no standard way to identify them, verify who they are, or define what they're authorized to do.
ERC-8004 is Ethereum's answer to that and this piece breaks down what it is, how it works, and whether it's ready to be taken seriously.
Today, when an AI agent makes payments or interacts with an API, there's no verifiable and standard way to answer:
Who is this agent and who deployed this agent?
Does it have a transaction history or reputation?
What permissions or roles does it have?
On the other end, humans, over decades, have designed portable identities to carry trust, reputation, and accountability with them.
Legal identities, licenses, credit history, financial statements, and more.
Today, since AI agents are handling real money, real data, and real decisions on behalf of real users, they need a reliable way to answer these questions at scale.
In less than 5 years, the infrastructure around AI agents has expanded and matured drastically. In this time, 3 key execution tracks came to life:
MCP standardized how agents access tools, making it possible for agents to query infrastructure, trigger workflows, and interact with external services.
A2A gave a structured messaging framework allowing agents to communicate with each other.
x402 gave them native payment rails, meaning agents can transact in stablecoins at the HTTP layer without needing humans.
💡Learn what x402 protocol is and how it works
Each protocol solved its specific problem well and today, execution is no longer a major headache for AI agents.
But, each of them runs into an identity or reputation wall very quickly.

Simply put, these protocols do not have the capability to answer who the agent is. That's the gap ERC-8004 is built to close.

ERC-8004 is an identity and reputation coordination standard designed for AI agents on Ethereum.
The proposal for this standard was authored by Marco De Rossi (MetaMask), Davide Crapis (Ethereum Foundation), Jordan Ellis (Google), and Erik Reppel (Coinbase).
The ERC-8004 standard introduces 3 onchain registries:
Each agent is represented by a unique onchain identifier which is further minted as an ERC-721 token. That NFT points to a structured JSON file, called an agent card, containing the agent's name, functionalities, service endpoints (MCP, A2A, web), and payment address.
The onchain component anchors identity. The offchain metadata provides context.
The reputation layer allows interactions and feedback to be recorded against an agent’s identity. It lets authorised agents and users post feedback in bounded numerical scores and categorical tags like response time or uptime.
This way, an agent's performance is made portable and queryable for other agents to learn from before interacting with them.
This registry is a standardized mechanism for recording verifiable evidence that an agent:
Completed a task
Produced a correct or acceptable output
Met predefined constraints or guarantees
Remember: this registry only defines how validation results are recorded, not which validation method to be used. Therefore, the registry is designed to support multiple validation strategies from social consensus to crypto-economic slashing.
It is, however, important to note that this registry isn't finished yet. Until it is shipped as infrastructure, the validation registry is a design space.
Together, these three registries create a neutral coordination layer: a way to discover agents > inspect their track record > and verify claims.
From here, the natural question follows: why not use existing identity systems instead?
If identity is the problem, why not use what already exists?
Developers today are familiar with OAuth, API keys, decentralized identifiers (DIDs), wallet addresses, and naming systems like ENS. Each provides a form of identification or authentication.
Why build something new?
Simple answer: Because ERC-8004 isn't solving the same problem.
Here's a quick table to understand the purpose of these systems and why ERC-8004 is necessary.
OAuth | DIDs (Decentralized Identities) | ENS | ERC-8004 | |
|---|---|---|---|---|
What’s the goal? | User authorization for applications | Decentralized identifiers | Human-readable naming for blockchain addresses |
Zooming out, each of these systems was designed with a specific trust surface in mind. And none of them were designed for AI agents except ERC-8004.
In theory, an agent registered under ERC-8004 can have an,
ENS name as its human-readable identifier,
DID for user-facing interactions, and
ERC-8004 specifically for agent-to-agent discovery and trust.
This way, ERC-8004 treats the other methods as composable primitives within its identity layer.
💡Bonus: Read our full guide on ENS Domains for Businesses
Now, how does the ERC-8004 discovery actually work in the real world?
A developer deploys an agent and registers it in the Identity Registry.
The agent receives an onchain identity with associated metadata describing its capabilities, exposed endpoints, and payment details.

Source: https://www.8004scan.io
Another agent or developer can now query the registry directly or via third-party indexers to discover agents using indexed metadata, capabilities, or available reputation signals.

Source: https://www.8004scan.io
Before interacting, the querying agent inspects the candidate’s Reputation Registry history, including prior outcomes, attestations, and linked evidence.
It decides whether the agent’s track record meets its risk threshold.
If acceptable, the agent connects using the advertised interface (MCP, A2A, or HTTP) and executes the task.
Payment is issued via x402 or another compatible mechanism. Outcome data and feedback may be written back to the Reputation Registry, updating the agent’s onchain track record for future discovery.
This is the coordination layer ERC-8004 introduces. Now, how does the full AI Agents tech stack actually look like for builders when it's assembled?
Today, the AI agent tech stack is a set of mature primitives working in combination. Here's a quick snapshot of what a builder has at their disposal:
Layer | Protocol | Function |
|---|---|---|
Identity & Trust | ERC-8004 | Who is this agent, what has it done, can it be verified |
Payments | Native value transfer at the HTTP layer, no intermediary | |
Tool Access |
Each layer makes the others more useful for AI agents.
An agent can discover another agent via ERC-8004.
It can pay that agent viax402.
It can invoke services through MCP-compatible endpoints.
💡Quick unlock: Learn how to build MCP servers on Solana for LLM integration
The value compounds when the layers interlock.
For builders, this stack has a practical implication: the infrastructure already exists to build agents that can be discovered by never-met-before agents, across organizational boundaries, compensated automatically, with a verifiable track record attached to every interaction.
Quicknode already powers key layers of this stack.
Agents querying ERC-8004 registry contracts need reliable RPC access and that'sQuicknode's core infrastructure
On the execution side, the Quicknode MCP Server connects AI assistants directly to blockchain data: RPC endpoints, indexing, and streaming, without custom integration work.
And Quicknode's x402 integration means agents can pay for RPC compute the same way they pay any other agent in the stack.
In effect, Quicknode supports identity lookups, execution access, and native agent payments and all with the enterprise-grade infrastructure and support that developers and teams need.
💡Good read: Quicknode is building how-to guides for integrating X402 payments, building web3-enabled AI agents, and more.
With all these information and tools handy, have we zeroed in on a complete infrastructure for the agent economy?
Not entirely. Not yet.
See, the agent economy will need a robust trust layer. The only open question, right now, is who defines it. There are two directions:
Build it now as an open standard, or
Wait until big tech with centralized directories to decide access and incentives for all.
ERC-8004 is the first serious attempt at the former: a permissionless, audited, institutionally-backed standard that no single entity controls.
It establishes the coordination surface where trust can emerge and thereby lays the groundwork for an open agent economy.
Founded in 2017, Quicknode deploys institutional-grade blockchain infrastructure for developers and enterprises. With 99.99% uptime and support for 80+ chains, teams build and scale onchain applications without compromise.
The latest engineering insights, product updates, and web3 news delivered straight to your inbox.
Who is it for? | Human users | Entities | Addresses and contracts | Autonomous agents |
Who controls it? | Centralized authorization servers | Identity owner | Onchain name registry | Permissionless, onchain registries |
Discovery model | Application specific | Identifier resolution | Name lookup (not discovery oriented) | Registry-based, open discovery |
Identity reputation or validation | None | None | None | Yes and natively. |
Designed for autonomous agents | No | Not specifically | No | Yes |
MCP / A2A |
Standardized interfaces for services and inter-agent coordination |

QuickNode •