ERC-8004: Identity and Reputation for Onchain AI Agents

Agents can already do a surprising amount together. They can message each other, discover each other's capabilities, and, with rails like x402, pay each other. There is one thing they still cannot do, and it is the thing that matters most for real commerce: prove to a stranger who they are and whether they can be trusted. Your agent meets an agent from another company it has never encountered. Should it hand over a task and a payment? On what basis? That is the gap ERC-8004 sets out to fill.

The hard problem is trust, not payments

This is the reframe worth sitting with. The agent economy's missing piece was never the payment rail. It was trust between strangers. ERC-8004, nicknamed Trustless Agents, is deliberate about this: it focuses on identity and trust primitives and leaves payment to other layers. It is positioned as a trust extension to agent-to-agent communication, adding the on-chain identity that those protocols lack, and it was developed in the open with involvement from the Ethereum Foundation.

Three registries

The whole design is three lightweight on-chain registries, with the heavy data kept off-chain to keep it cheap:

• Identity Registry. Each agent is an NFT with a unique identifier and an off-chain profile that lists its name, endpoints, and the trust models it supports. Because identity is a token, an agent's record is portable and browsable with ordinary wallet tooling.
• Reputation Registry. A place for signed feedback about an agent's past work, stored so anyone can compose on top of it, with heavy aggregation done off-chain.
• Validation Registry. The part that actually matters for high stakes. It lets independent validators verify an agent's output and return a score, through different mechanisms depending on how much trust the task requires.

That last point is the key to the whole design, because the three trust models are meant to escalate with the stakes:

Reputation is cheap and weak. Re-execution backed by stake is stronger, because a validator re-runs the work and has money at risk. Hardware attestation and zero-knowledge proofs are the strongest, verifying the work without trusting anyone's word. The point of putting identity on-chain is not decentralization as a slogan; it is that an agent's reputation becomes portable and platform-independent, owned by no single marketplace.

The honest part: reputation is easy to game

Here is where a lot of write-ups go quiet, and I would rather not. Reference contracts went live on Ethereum mainnet in early 2026, with tens of thousands of agents registering on testnets. But an independent study published in mid-2026 took a hard look at the live ecosystem and found uncomfortable things: most identity registrations were empty placeholders with no working endpoints, reputation values were rarely grounded in real interactions, and a large majority of reviewers across the chains showed coordinated, sybil-like behavior. Strip out the manipulated feedback and most rated agents lost all of their valid reviews.

The takeaway is not that ERC-8004 is broken. It is that raw reputation, stars and scores, is a weak trust signal that can be bought cheaply. Which is exactly why the standard separates validation from reputation in the first place. When real value is on the line, you want proof the work was done correctly, re-execution, stake, or a hardware attestation, not a five-star average that an attacker minted last week. The design anticipated the failure the study documented. The ecosystem just has not caught up to using the strong parts yet.

What to actually take from it

• The problem it names is the right one. Agent commerce across organizations needs trust between strangers, and no protocol had a clean answer before this.
• Portable reputation is the real prize. An agent that carries its track record across platforms, owned by no single one, is genuinely new, and only an open, on-chain identity gives you that.
• Validation matters more than stars. Because reputation is gameable, gate high-stakes agent actions on proof or stake, and treat reputation as a soft, secondary signal.

And keep the status in mind: this is a draft standard with live contracts. Build against it to learn, expect the interface to move, and do not put serious money behind a raw reputation score yet.

Where we sit

We build in exactly this space, agents that transact, the agentic commerce around them, and the agentic payments rails they settle on. Identity and trust are the missing layer that makes agent-to-agent commerce safe to actually run, and ERC-8004 is the most serious attempt at it so far, warts and all. If you are building agents that will transact with agents you do not control, this is the layer to watch, and the conversation to have.

References

• ERC-8004 specification (Draft): the Identity, Reputation, and Validation registries.
• Ethereum Magicians: ERC-8004 Trustless Agents discussion: the proposal, provenance, and design debate.
• Can Trustless Agents Be Trusted? (arXiv 2606.26028): the independent study on gamed reputation and placeholder registrations.