For most of the last two years, the interesting question about AI agents was whether they could do the work. That question is mostly settled. An agent can call an API, hold a conversation, move money, chain a dozen tools together, and hand a finished task back to you. The capability is no longer the hard part.
The hard part is the one nobody wants to look at, because it isn’t glamorous: when an agent shows up to do a job, how do you know which agent it is? How do you know it’s the one with the track record, and not a fresh identity wearing the same name? How do you check that the work it says it did is the work it actually did? And how do you do any of that without a platform in the middle vouching for everyone and taking a cut?
That is the gap the standard was written to close. It is not a flashy thing. It does something narrow and does it deliberately. But the narrowness is the point, and understanding why is worth your time — because the same gap it closes for agents is the gap that has been open for people since the web began, and closing it raises a question the standard itself never asks: once identity can be owned rather than lent, who should own it? My answer, which this article builds toward, is that a capability this fundamental belongs to a sovereign namespace — something a State can hold outright — not to another platform.
What ERC-8004 Actually Is
ERC-8004, titled “Trustless Agents,” is an Ethereum standard. It was drafted through 2025 by contributors from MetaMask, the Ethereum Foundation, Google, and Coinbase, and ratified in early 2026. It is an application-layer standard built on existing Ethereum primitives, not a change to the protocol itself. And it is emphatically not a token — you cannot buy it, trade it, or hold it as an asset.
What it defines is three lightweight onchain registries, deployed once per chain as singletons, that together give an agent a spine: identity, reputation, and validation.
The Identity Registry. This is the anchor. Each agent mints an ERC-721 token — the same standard behind NFTs — and that token is the agent’s identity. The token ID is its unique handle; the token URI points to an off-chain “registration file,” a JSON document that describes what the agent is, what it can do, where to reach it, and which wallet it gets paid at. Because it’s an ERC-721, the identity is portable, browsable, and transferable using tooling that already exists. An agent registered on one platform can be recognized on another without asking permission from either.
The Reputation Registry. Once an agent has an identity, other parties can post feedback against it — bounded scores, categorical tags like response time or accuracy. The actual feedback data lives off-chain; what the registry records onchain is the authorization to post it, creating a permanent, crawlable audit trail. Anyone can read that trail and build their own scoring on top of it. A track record that follows the agent, that it cannot quietly reset by spinning up a new account.
The Validation Registry. Reputation is a soft signal — it tells you what others thought. For higher-stakes work you sometimes need proof, not opinion. The Validation Registry is where independent validators post verifiable results about an agent’s work: a re-execution of the task by a staked party, a cryptographic proof, an attestation from a trusted execution environment. The standard is deliberately unopinionated about how validation happens — it only fixes where the result is recorded.
That’s the whole thing. Three registries. An anchor, a track record, and a proof mechanism. Everything else — payments, application logic, the actual work — is left out on purpose.
Why the Omissions Matter More Than the Features
The first time I read the spec, the part that convinced me wasn’t what it included. It was what it refused to include.
ERC-8004 does not define a payment system. It does not define a reputation scoring algorithm. It does not define what makes an agent “good” or how validation should be performed. It could have. A less disciplined standard would have bundled all of that in and shipped something impressive and unusable.
Instead it keeps only the skeleton of trust onchain — identities and pointers to the data — and leaves the data itself, and all the opinionated logic, to the ecosystem. This is the same restraint that a good security audit shows when it names what it didn’t look at. It’s the difference between a standard that tries to be a product and a standard that tries to be a foundation. Products age. Foundations get built on.
The payoff of that restraint is composability. Because 8004 doesn’t force a payment model, it slots cleanly next to x402, the emerging standard for agent payments. Because it doesn’t force a validation method, it works whether you want social consensus for low-stakes tasks or cryptographic proof for financial ones. Because the identity is a plain ERC-721, every wallet and indexer that already understands NFTs understands an 8004 agent for free. The standard is small so that the things built on it can be many.
The Part Nobody Says Out Loud
Here is what struck me, and it’s the reason this article exists.
Read the three registries again — identity, reputation, validation — but take the word “agent” out. A portable identity that’s yours and can’t be forged. A reputation that follows you and that you can’t secretly reset. A record of your work that anyone can verify without trusting a middleman.
That is not an agent problem. That is the oldest unsolved problem of the human web.
For thirty years, your identity online has been something a platform lends you. Your handle belongs to the company whose logo is in the corner. Your reputation — your followers, your history, your standing — is trapped inside their database and evaporates the moment they ban you, rename you, or shut down. You cannot take it with you. You cannot prove it independently. You are, in the most literal sense, renting the right to be yourself.
ERC-8004 solves exactly that problem. It just happens to solve it for agents first, because agents are the ones nobody had built it for yet, and because the money in the agent economy made it urgent. But the mechanism — an ERC-721 identity, owned by a key you hold, resolving to a file you control, carrying a record no one can revoke — doesn’t care whether the thing behind the name is a piece of software or a person.
What I Built On It — and Who It’s For
This is where I stop describing someone else’s standard and tell you what I did with it, because I don’t think it’s honest to write about a protocol in the abstract when I’ve put my own work on top of it.
I’ve built an identity layer on the same registries. The idea is simple to state: any name you own should be able to carry a live onchain identity — verifiable by anyone, forgeable by no one. The name stops being a label and becomes the thing itself. The agent. The person. Whatever holds the key behind it. On the agent side, that’s a name that acts, that can be discovered and hired and paid, and that answers only to its owner. On the human side, it’s the same machinery turned toward a different problem: a name that proves the person behind it is really them — a human, not a bot, not a clone — and that stays theirs no matter which platform they walk into. Two faces of one layer.
But the part that matters most is not the standard. It’s who gets to own the layer. And here is the argument I care about: this capability — to activate an identity and a reputation that no one can revoke — is exactly the kind of thing a State should be able to hold for itself. Not lease from a platform. Not depend on a foreign company to grant. Own, outright, as a sovereign function.
That is why this capability belongs with the namespace itself, not bolted on as a separate product. A State — or anyone — that owns its names should also be able to activate, on top of them, an identity and a reputation it controls end to end. The name proves ownership; the layer above turns that name into something that can act, be trusted, and carry a verifiable record — owned outright, and revocable by no outside party.
I want to be careful, because this is exactly the kind of claim that’s easy to inflate. The registries are real, ratified, and live. What I’ve built on top is being brought online in the open, piece by piece, the same way I build everything — on a schedule, in public, with the gaps visible rather than papered over. I’d rather tell you what’s live and what’s still under construction than sell you a finished picture that doesn’t exist yet.
Why This Is a Sovereignty Question
The honest limitation of any identity standard is the same: it can prove that a name corresponds to an onchain identity, but it cannot by itself prove that the thing behind the identity is competent, honest, or safe. That’s what the reputation and validation layers are for — where “who you are” turns into “whether you can be trusted.” Identity is necessary and nowhere near sufficient. Anyone who tells you a standard makes trust automatic is selling a false endpoint.
But necessary things are worth building well, and worth owning. For the entire history of the internet, the base layer of identity has been owned by whoever ran the server — a platform, a company, a party that could revoke it. Moving that base layer out from under any single owner and making it something a person, or a State, can hold directly is the whole point. And a State that can hold its own identity layer is more sovereign than one that merely hosts its data domestically. It is the difference between owning who you can vouch for and renting it.
That is the version of this I’m building toward. A sovereign namespace that also carries sovereign identity — for people and for the agents acting on their behalf — is not two things but one: whoever controls their own names controls, through them, their own ability to say who is who and who can be trusted, with no outside party able to revoke it. The name is the identity. And when the name is owned outright, so is everything built on top of it.