ERC-8004 is an Ethereum standard that gives AI agents a verifiable on-chain identity, a public reputation record, and a way to prove their work was done correctly. It does this with three smart contract registries that any agent can register in, and any other agent can read from — no gatekeeper, no approval process.
The problem it solves is narrow and specific. AI agents can already talk to each other, call tools, and move money. What they cannot do is answer a simple question about a stranger: who are you, and has anyone worked with you before?
The registries went live on Ethereum mainnet on January 29, 2026. Within a month, more than 45,000 agents had registered across the networks where the contracts are deployed. Whether those registrations mean much yet is a separate question, and one worth looking at honestly — we’ll get to the data further down.
This guide covers what ERC-8004 does, how each registry works, how it compares to existing identity systems, and what the on-chain evidence says about real usage so far.
Why AI Agents Need an Identity Standard
Before ERC-8004, there was no shared answer to “who is this agent.” Think about hiring a contractor: you check their license, look at reviews, maybe ask for references. Every one of those steps is an identity and reputation lookup, and the infrastructure behind them took decades to build.
AI agents have none of that. An agent hiring another agent has no way to check whether the counterparty is a well-tested service or a wrapper someone deployed twenty minutes ago. Both look identical from the outside: an endpoint and a promise.
This matters more as agents start handling real value. The current answer to “should I trust this counterparty” is usually “the platform vouches for it,” which works fine inside one company and breaks the moment agents from different organizations need to work together.
The Protocols That Got Us Halfway
Three standards already solved big pieces of the agent problem. MCP (Model Context Protocol) standardized how agents access tools and data. A2A (Agent2Agent), which Google donated to the Linux Foundation in June 2025, gave agents a structured way to message each other and manage task lifecycles. A third layer handles payments, letting agents settle transactions without a human approving each one.
Each works well. But all three assume you already know who you’re talking to. Marco De Rossi, AI Lead at MetaMask and the lead author of ERC-8004, hit this wall directly when he studied the A2A specification:
“A2A assumes usage within organizations — discovery and trust assumptions were overlooked.”
That gap is the whole reason ERC-8004 exists. Agents could execute; they just couldn’t find each other or decide whether to trust what they found. An AI agent identity standard was the missing piece, and it had to be neutral — no single company could own the registry that everyone else depends on.
What ERC-8004 Actually Is
ERC-8004 was proposed on August 13, 2025 by four authors from four organizations that rarely ship a spec together: Marco De Rossi (MetaMask), Davide Crapis (Ethereum Foundation), Jordan Ellis (Google), and Erik Reppel (Coinbase). That authorship list is a signal in itself — this is not a single-vendor proposal.
The ERC-8004 design is deliberately minimal. The blockchain stores pointers, identifiers, and small numeric signals. Everything heavy — the actual agent logic, the full feedback text, the validation evidence — lives off-chain. That split is what keeps blockchain AI identity cheap enough to be practical: you’re writing a few dozen bytes per agent, not a model. Here’s how the three registries divide the work.
Identity Registry
Every agent is minted as an ERC-721 token. That’s the same standard behind NFTs, which is a genuinely clever reuse: agents become browsable in any existing NFT explorer, transferable between owners, and readable by indexers that already exist.
The token ID becomes the agentId. The token URI points to a JSON file — the agent registration file — that describes what the agent does and where to reach it. Agents are globally addressed as {namespace}:{chainId}:{registryAddress}, so an agent registered on Ethereum can be referenced unambiguously from anywhere.
One detail worth flagging: the registry reserves an agentWallet metadata key for the address where an agent receives payments. Changing it requires a signature proving control of the new wallet, and it’s cleared automatically when the agent is transferred. This is critical — it stops a bought or stolen agent identity from silently redirecting funds.
Reputation Registry
Feedback is stored as a signed number plus a decimal place: value as an int128, and valueDecimals between 0 and 18. So 9977 with 2 decimals means 99.77%, and 560 with 0 decimals means 560 milliseconds.
Two optional tags describe what’s being measured — uptime, responseTime, successRate, starred. The schema is intentionally loose, because nobody knows yet which metrics will matter. Longer feedback goes in an off-chain file, referenced by URI with a hash so the content can’t be swapped later.
Agents can’t rate themselves. The contract checks the Identity Registry and rejects feedback from an agent’s owner or approved operators.
Validation Registry
This is the piece for high-stakes work, where a reputation score isn’t enough. An agent requests verification of a specific task, and a designated validator contract responds with a score from 0 to 100.
The registry deliberately takes no position on how validation happens. A validator might re-run the job with staked collateral at risk, verify a zero-knowledge proof of the model’s execution, or attest via a trusted execution environment. The registry just records who validated what and what they concluded.
Be aware that this registry is the least settled part of the standard. The reference implementation carries an explicit warning that the validation spec is still under active discussion with the TEE community and will be revised. Treat it as a working design space, not a finished interface.
The Agent Registration File
The on-chain ERC-8004 record is just a pointer. The registration file it points to is where an agent actually describes itself (abridged):
{
"type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
"name": "myAgentName",
"description": "What this agent does, how it prices work, how to reach it",
"services": [
{ "name": "A2A", "endpoint": "https://agent.example/.well-known/agent-card.json" },
{ "name": "MCP", "endpoint": "https://mcp.agent.eth/" },
{ "name": "ENS", "endpoint": "myagent.eth" }
],
"registrations": [
{ "agentId": 22, "agentRegistry": "eip155:1:0x8004A169..." }
],
"supportedTrust": ["reputation", "crypto-economic", "tee-attestation"]
}Notice the supportedTrust field. An agent declares upfront which trust models it participates in, so a counterparty can filter before ever making a request. An agent offering only reputation is fine for low-stakes work and probably wrong for anything involving significant money.
The file can live on IPFS, on HTTPS, or be embedded on-chain as a base64 data URI. Agents advertising an HTTPS endpoint can optionally prove they control that domain by hosting a well-known file — a useful defence against an agent claiming endpoints it doesn’t own.
How ERC-8004 Differs from ENS, DIDs, and OAuth
The obvious objection: we already have identity systems. Why build another one?
Because none of them were designed for machines choosing counterparties autonomously. Each solved a different trust problem, and ERC-8004 is the first to treat the agent itself as the subject.
| OAuth | DIDs | ENS | ERC-8004 | |
|---|---|---|---|---|
| Built for | Human users | People and organizations | Addresses and contracts | Autonomous agents |
| Controlled by | Central auth servers | The identity owner | On-chain name registry | Permissionless registries |
| Discovery | App-specific | Identifier resolution | Name lookup only | Open, registry-based |
| Reputation built in | No | No | No | Yes |
| Validation built in | No | No | No | Yes |
Here’s the part people miss: these aren’t competitors. An ERC-8004 agent can list an ENS name and a DID among its service endpoints. The standard treats existing identity primitives as things to reference, not replace — which is why adopting it doesn’t mean tearing out whatever you already use.
How the Standard Works End to End
The full ERC-8004 lifecycle is five steps, and it’s simpler than the contract signatures suggest.
- Register. A developer calls
register()on the Identity Registry and receives anagentId. The registration file goes on IPFS or HTTPS, and its URI is attached to the token. - Discover. Another agent queries the registry — directly, or through an indexer — filtering by capabilities and declared trust models.
- Evaluate. The querying agent reads the candidate’s feedback history via
getSummary()orreadAllFeedback(), and decides whether the track record clears its risk threshold. - Interact. If it does, the agent connects over whichever interface was advertised and the work happens.
- Record. Feedback goes back to the Reputation Registry with
giveFeedback(), updating the record future counterparties will read.
Payments sit deliberately outside this loop. The authors kept settlement out of scope so the standard wouldn’t be coupled to any one payment protocol, though the spec does show how proof of payment can be attached to feedback as an optional field.
Who’s Actually Using ERC-8004 — And What the Data Shows
Adoption numbers look excellent. During roughly three months on testnet, the ecosystem logged over 10,000 agents and 20,000 feedback entries. After the January 2026 mainnet launch, tracker 8004 Scan recorded more than 45,000 registered agents within the first month across the chains where the registries are deployed.
The Identity and Reputation registries now live at the same vanity addresses across 24 mainnet networks at the time of writing — Ethereum, Base, Arbitrum, Optimism, Polygon, BNB Smart Chain, Avalanche, Linea, Scroll, Monad, and more. The Identity Registry sits at 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432 on every one of them, which makes cross-chain integration close to trivial.
Now the honest part.
In June 2026, researchers Rischan Mafrur (Western Sydney University) and Priagung Khusumanegara published an empirical study of the first 10,000 agents registered on Ethereum mainnet. Their conclusion was blunt: early adoption is “registration-heavy but operationally shallow.”
The specifics are worth sitting with:
| Metric | Finding |
|---|---|
| Agents with any feedback record | 628 of 10,000 (6.28%) |
| Unique owner wallets | 394 |
| Largest single owner | 779 agents |
| Ownership Gini coefficient | 0.863 |
| Share of all feedback from one address | 65.8% |
| Agents with more than one feedback client | 18 |
Read that last row again. Out of 10,000 registered agents, eighteen have been rated by more than one party. A reputation system where nearly every agent has at most a single reviewer isn’t yet a reputation system — it’s a database with reputation-shaped columns.
None of this means the standard failed. Infrastructure gets built before the activity that uses it, and concentrated early ownership is normal when developers are the first participants. But the honest description of ERC-8004 in mid-2026 is a working identity layer with a reputation layer that hasn’t filled in yet.
Davide Crapis, who leads AI work at the Ethereum Foundation, frames the long game less in terms of agent counts and more in terms of what the network is for:
“In a world where AI is in the wild, we want Ethereum to be the place with the big lock. If I have the keys, I still have power.”
What ERC-8004 Doesn’t Solve
Three limitations of ERC-8004 are worth understanding before building on it.
Sybil attacks are possible and acknowledged. Registration is permissionless, so nothing stops someone minting a thousand agents and having them rate each other. The spec’s own security section admits this. Its answer is that filtering by reviewer is the consumer’s job — which is why getSummary() requires you to pass a list of client addresses rather than returning a global average.
The standard is still formally a Draft. The contracts are live and handling real registrations, but the ERC has not been finalized, and the Validation Registry in particular is expected to change. Build accordingly.
Registration proves nothing about capability. The spec is explicit: it can cryptographically tie a registration file to an on-chain identity, but it cannot guarantee the advertised capabilities work or that the agent isn’t malicious. That’s what the trust models are for, and they only help if someone actually uses them.
How to Query Agent Registries in Your Application
Reading ERC-8004 data means making standard contract calls against whichever network you care about. Since the registries are deployed at identical addresses across chains, the only thing that changes between networks is your endpoint. No SDK is required — this is plain contract reads.
NOWNodes provides API access to over 110 blockchains, including every major network where ERC-8004 registries are currently deployed. You sign up, generate a key, and query the contracts directly:
- Get an API key at nownodes.io — the free START plan covers 100,000 requests, which is plenty for building and testing an agent discovery flow.
- Point at your network. Your endpoint follows the format
https://eth.nownodes.io/your_api_key, swapping the prefix for Base, Polygon, BNB Smart Chain, or any other supported network. - Call the registries. Use
eth_callagainst0x8004A169FB4a3325136EB29fA0ceB6D2e539a432for identity lookups, or the published ABIs with ethers.js or web3.py. - Track new registrations by subscribing to the
RegisteredandNewFeedbackevents rather than polling — far cheaper on request volume.
Because every mainnet deployment shares an address, an agent discovery service can scan a dozen networks with the same call and only vary the endpoint.
The Bottom Line
ERC-8004 does one thing well: it gives AI agents a portable, permissionless identity that any other agent can look up and evaluate. The ERC-721 foundation means it inherits tooling that already exists, and the minimal on-chain footprint keeps costs low enough that registering thousands of agents is practical. As an agent identity standard, it is close to the smallest thing that could work — which is a compliment.
What it hasn’t produced yet is a functioning reputation economy. The data from the first 10,000 mainnet agents is clear: registration is happening at scale, meaningful feedback is not. That gets solved by agents doing real work for each other, not by more registrations.
For developers, the practical read is straightforward. The identity layer is production-ready and cheap to integrate, so build discovery on it now. Treat reputation signals as early-stage data, and don’t lean on the Validation Registry until the spec settles.
The bet underneath all of this, as De Rossi put it, is that the ecosystem has “incredible latent demand for applying the Web3 principles we all care about to AI.” Whether that shows up as economic activity rather than registrations is the thing to watch over the next year.
Frequently Asked Questions
Is ERC-8004 finalized?
No. It remains in Draft status in the official ERC repository, though the reference contracts have been live on Ethereum mainnet since January 29, 2026. The Identity and Reputation registries are stable in practice; the Validation Registry is still being revised.
Does ERC-8004 handle payments between agents?
No, and that’s intentional. The authors kept settlement out of scope to avoid coupling the standard to any single payment protocol. Proof of payment can be attached to feedback as an optional field.
What does it cost to register an agent?
Registration is a standard ERC-721 mint, so you pay gas and nothing else. There’s no protocol fee and no stake requirement. Costs vary by network — registering on a Layer 2 is dramatically cheaper than on Ethereum mainnet.
Can an agent identity be transferred or sold?
Yes. Agents are ERC-721 tokens, so ownership transfers like any NFT. The agentWallet is cleared on transfer, so the new owner must prove control of a payment address before receiving funds.
How is this different from just giving an agent a wallet?
A wallet proves control of a key. It says nothing about what the agent does, where to reach it, or whether anyone has worked with it successfully. ERC-8004 adds the discovery and track-record layers on top, which is what makes trustless AI agents workable between strangers.
Which networks support ERC-8004?
The Identity and Reputation registries are deployed at identical addresses across 24 mainnets, including Ethereum, Base, Arbitrum, Optimism, Polygon, BNB Smart Chain, Avalanche, Linea, Scroll, and Monad, plus matching testnets. The current list lives in the official contracts repository.
