Quicknode

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.

Identity Crisis of the Agent Economy

Today, when an AI agent makes payments or interacts with an API, there's no verifiable and standard way to answer:

1. Who is this agent and who deployed this agent?

2. Does it have a transaction history or reputation?

3. 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.

The AI Agents Stack Grew Fast and Incomplete

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:

1. MCP standardized how agents access tools, making it possible for agents to query infrastructure, trigger workflows, and interact with external services.

2. A2A gave a structured messaging framework allowing agents to communicate with each other.

3. x402 gave them native payment rails, meaning agents can transact in stablecoins at the HTTP layer without needing humans.

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.

What ERC-8004 Actually Is

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:

1. Identity Registry

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.

2. Reputation Registry

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.

3. Validation Registry

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?

How ERC-8004 Differs from OAuth, DIDs, and ENS

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.

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.

Now, how does the ERC-8004 discovery actually work in the real world?

How ERC-8004 Actually Works End-To-End (Without Code)

Step 1: Register

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

Step 2: Discover

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

Step 3: Evaluate

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.

Step 4: Interact

If acceptable, the agent connects using the advertised interface (MCP, A2A, or HTTP) and executes the task.

Step 5: Pay and Record

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?

The Emerging Agent Stack

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:

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.

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.

Where Quicknode Sits in the Agent Stack

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.

With all these information and tools handy, have we zeroed in on a complete infrastructure for the agent economy?

Does ERC-8004 Complete the AI Agent Infrastructure?

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.