ERC-8004: Trustless Agent Identity and Reputation
An AI agent that works across company or application boundaries needs more than a way to send messages: a caller also needs to identify the service, discover what it offers, and judge whether its results are dependable. ERC-8004 proposes blockchain registries for agent identity, reputation, and independent validation. This explainer is for developers designing multi-agent systems; it separates the proposal’s trust layer from protocols that carry tasks or payments, and describes what the registries can and cannot prove.
What Is ERC-8004?
ERC-8004 is a draft Ethereum standard that proposes three registries for agents: an identity registry, a reputation registry, and a validation registry. Their purpose is to make it possible to discover and evaluate agents operated by different organizations without requiring a pre-existing account relationship. The EIP document describes interfaces and data structures; its current status is Draft, not an adopted guarantee that compatible deployments exist on every chain.
The 8004 project homepage presents the broader effort around open agent protocols. In the proposal, an on-chain identity points to an agent registration file that can advertise service endpoints, supported protocols, and trust mechanisms. Other participants can publish feedback or request validation through the other registries. Applications decide how much weight to give those records.
ERC-8004 is not an agent runtime, an AI model, or a mechanism that makes a remote agent inherently trustworthy. It supplies shared registry interfaces and references that applications can incorporate into their own discovery and policy decisions.
The Problem ERC-8004 Tries to Solve
Agent protocols can standardize how two applications find a connection and exchange work, but they do not automatically provide a portable record of an agent’s identity or past performance. A consumer might have to rely on a vendor directory, a private marketplace, or a manually configured allowlist. Those approaches can be appropriate inside one organization, but are harder to reuse across independent operators.
A public registry offers a common place to look up an identifier and related signals. For example, a consumer can resolve an agent’s registration, inspect its advertised A2A or MCP endpoint, and retrieve feedback associated with that identity. The registry does not ensure the endpoint is available, the metadata is truthful, or a feedback author is unbiased. It makes records easier to reference; it does not remove the need to verify them.
This distinction matters because agent systems combine different boundaries. A2A defines communication and task delegation between agents, while MCP connects AI applications to tools and data. ERC-8004 focuses on identity and trust signals around those interactions. x402 addresses internet-native payments, which the ERC-8004 proposal treats as a separate concern.
How ERC-8004 Works
An implementation can deploy the registries on a supported chain and use an agent’s registry identifier and agent ID to refer to its record. The registration points to a file, commonly JSON, that lists service endpoints and optional metadata. Clients can index or retrieve registry events and files, then apply their own rules before connecting or delegating work.
| Dimension | ERC-8004 | A2A | MCP | x402 |
|---|---|---|---|---|
| Primary purpose | Register agent identity and trust signals | Delegate tasks and exchange results between agents | Connect an AI host to tools and data | Negotiate payment for an HTTP resource |
| Main reference | Chain, registry address, and agent ID | Agent Card and endpoint | Server and advertised capabilities | HTTP payment challenge and payment payload |
| Typical records or messages | Registration, feedback, validation request/result | Messages, tasks, and artifacts | Tool, resource, and prompt operations | Price terms, authorization, and settlement result |
| Trust boundary | Registry records and the systems interpreting them | Caller and remote agent authentication/policy | Host and server authorization | Buyer, seller, wallet, and payment facilitator |
| Does it perform the others’ job? | No; it does not carry an agent task | No; it does not establish a universal reputation | No; it does not register agents across organizations | No; payment does not establish agent identity or quality |
These components can be composed. A marketplace could use ERC-8004 records to find candidate agents, use A2A to assign a task, use MCP within an agent to access approved tools, and use x402 to pay for a resource. Each boundary still needs independent authorization, failure handling, and monitoring. A reputation score should not be treated as permission to disclose sensitive data or execute a consequential action.
Components and Key Concepts
Identity Registry. The proposal builds an agent reference from a namespace, chain ID, registry contract address, and agent ID. The identity registry uses an ERC-721-style token and URI storage to point at a registration file. The file can advertise service names, endpoints, versions, and optional trust claims. Since the token can be transferred, systems should also account for ownership changes; a stable ID is not proof that its current controller is the original operator.
Agent Registration File. This is the machine-readable description behind the identifier. It can describe an A2A Agent Card endpoint, an MCP server, an HTTPS service, or other endpoint. The proposal also describes an optional domain verification file so an endpoint operator can demonstrate that it controls a domain and that the domain references the expected on-chain registration. Consumers must still validate TLS, content, and the endpoint’s behavior.
Reputation Registry. Clients can submit feedback linked to an agent, with a value, optional tags, and references to supporting data. The registry provides a common interface for recording and retrieving such signals; applications can aggregate them on-chain or off-chain. A number is not an objective quality measure by itself: weighting, context, identity of reviewers, and resistance to Sybil accounts all affect how useful it is.
Validation Registry. A requester can record a validation request and a validator can publish a result. The proposal allows different mechanisms, such as a verifier re-running a task, a trusted execution environment attestation, a proof system, or a human judge. The registry is a coordination and record-keeping interface, not a proof that every validation method is sound. Consumers need to understand the validator’s assumptions and what exactly was checked.
Wallet and ownership metadata. The draft includes a separately managed agent wallet field with signature-based control checks. This is relevant when an agent receives payments, but the wallet is not the same thing as its registry identity or service endpoint. Applications must verify the expected chain, contract, signer, and authorization before treating these values as equivalent.
Real-World Use Cases
- Agent directories: A client can query a registry for agents advertising a required skill, then inspect their endpoints and supported trust mechanisms before connecting.
- Cross-organization task sourcing: A buyer can discover agents outside its own vendor catalog and combine registry information with its existing security and procurement checks.
- Feedback-aware routing: A coordinator can compare task-specific feedback signals when selecting between eligible agents. It should retain the evidence and use thresholds appropriate to the task rather than blindly sort by a global score.
- Higher-assurance workflows: A workflow can request independent validation for a result whose value or risk justifies additional cost. The policy should specify the verifier and the evidence expected before work begins.
These patterns are most useful when agents are independently operated and need a shared discovery surface. For a small, centrally managed group, a database and explicit allowlist may be simpler and easier to govern.
Getting Started: Inspect a Registration
Do not begin by sending a transaction to an address copied from an example. First confirm the current draft, supported chain, registry deployment, and implementation version from the project’s maintained documentation. ERC-8004 is still marked Draft, so deployment addresses and interfaces must be verified for the network you intend to use.
A registration file can advertise an A2A service and declare the trust signal it supports. This illustrative JSON follows the proposal’s registration shape; the endpoint, registry address, and ID are placeholders, not a live agent:
{
"type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
"name": "Example research agent",
"description": "Produces source-linked summaries of public technical documents.",
"image": "https://agent.example.org/avatar.png",
"services": [
{
"name": "A2A",
"endpoint": "https://agent.example.org/.well-known/agent-card.json",
"version": "1.0"
}
],
"active": true,
"registrations": [
{
"agentId": 123,
"agentRegistry": "eip155:1:0x0000000000000000000000000000000000000001"
}
],
"supportedTrust": ["reputation"]
}
Save it as registration.json. Use jq to check that it parses and includes a few fields your integration requires. Install jq with your operating system’s package manager if it is not already available:
# Debian or Ubuntu
sudo apt-get install jq
# macOS with Homebrew
brew install jq
# Windows with WinGet
winget install jqlang.jq
Then validate the example locally:
jq -e '
.type == "https://eips.ethereum.org/EIPS/eip-8004#registration-v1" and
(.name | type == "string" and length > 0) and
(.services | type == "array") and
(.registrations | type == "array" and length > 0) and
(.active | type == "boolean")
' registration.json
An exit status of zero means the JSON parsed and those basic checks passed; it does not establish conformance to every draft requirement or authenticate an agent. For an actual integration, resolve the registration from the chain and registry address named by its identifier, verify that the returned ID and file agree, fetch advertised endpoints over HTTPS, and apply the optional domain-registration check where supported. Test how your client handles missing metadata, a changed endpoint, ownership transfer, duplicate feedback, unavailable validators, and an unavailable chain indexer. Keep signing keys out of registration files and logs.
Before using a record to route work, define what counts as acceptable evidence: who may submit feedback, what a validation result covers, how old records expire, and which actions still require direct authorization or human review. Follow the key words in the EIP in their normative context; RFC 2119 explains how terms such as MUST and SHOULD express requirement levels in standards documents.
Common Misconceptions
“Trustless means trust-free.” The registries can reduce dependence on one private directory, but clients still trust chain security, contract implementations, data availability, validators, and their own scoring policy.
“An identity token proves an agent is safe.” It provides a reference and ownership model. It does not certify the operator, endpoint, model, or output, and a token transfer can change who controls the record.
“A high reputation score is proof of quality.” Feedback can be manipulated, purchased, or irrelevant to a particular task. Consider provenance, recency, task similarity, and independent validation instead of trusting an aggregate alone.
“ERC-8004 replaces A2A, MCP, or payment protocols.” The registries do not deliver tasks, execute tools, or settle payments. They complement these systems by providing identity and trust-related references.
Related Articles
- A2A protocol architecture explains agent-to-agent discovery, task exchange, and results.
- Model Context Protocol (MCP) explained covers connecting AI applications to tools and data.
- How x402 makes API payments work over HTTP explains a separate payment boundary for HTTP resources.
Changelog and Last Updated
- Initial publication. Last updated: November 20.

