ERC-8004 “Trustless Agents” is the loudest story in agent trust right now, and it has earned the attention: a draft Ethereum standard for discovering and evaluating autonomous agents, live on mainnet since January 2026, with announced integrations from ENS, EigenLayer and The Graph and thousands of builders behind it. It starts from the same diagnosis MintID does — A2A and MCP let agents talk, but neither answers “can I trust this one?”. It then gives a very different answer. This comparison lays both out honestly, including what ERC-8004 simply does better. ERC-8004 facts below come from the draft specification and its public discussion thread, as of July 2026.
The short version
| dimension | erc-8004 | MintID |
|---|---|---|
| what it is | three registry contracts on any EVM chain | a sovereign identity Layer-1 (Cosmos SDK) |
| agent identity | a public ERC-721 NFT per agent, per chain | no on-chain agent record — a normative “won’t have” |
| transferability | the agent NFT sells like any token, reputation attached | credentials are holder-bound; recovery only by re-KYC |
| human behind the agent | none required — owners can be fully anonymous | the whole product: every credential backed by a verified, liable human |
| trust signal | open feedback registry + staked validation | issuer bond + escrow; no reputation scores at all |
| privacy | identity and feedback public and correlatable by design | pairwise pseudonyms, unlinkable sibling agents, no presentation logs |
| what gets validated | the agent’s work (re-execution, TEE attestation) | the agent’s backing (a ten-second zero-knowledge proof) |
| recourse for victims | out of scope — slashing left to external protocols | core: escrow first, identity last, bonded arbitration between |
What ERC-8004 gets right
ERC-8004 defines three singleton registries per EVM chain. The Identity Registry mints each agent as an ERC-721 token whose URI resolves to a registration file — name, A2A/MCP endpoints, x402 payment support, a proven payout address. The Reputation Registry lets any address publish signed, revocable feedback about an agent. The Validation Registry lets an agent request independent validation of its work — inputs and outputs referenced by hash, verdicts from validators who re-execute the job with stake at risk or attest it ran in a trusted enclave.
Three of those moves are genuinely valuable, and MintID does not attempt any of them. Discoverability: agents become browsable, indexable objects with standard metadata — a real directory problem, solved. Work validation: “did the agent do the job correctly?” gets a portable, composable answer. Ecosystem fit: the standard plugs into A2A, MCP and x402 rather than competing with them — the same bridge-don’t-fight posture MintID takes. And the specification is refreshingly honest: it admits openly that unfiltered reputation aggregation “invites Sybil inflation” and that serious aggregation will happen off-chain.
That admission is where the two designs part ways. Both projects agree naked reputation is gameable. ERC-8004 responds with filters and economic validation. MintID responds with a verified human and funded recourse.
Identity you can sell is accountability you can shed
In ERC-8004, an agent’s identity is an NFT — and NFTs transfer. Buy the token of a well-reviewed agent and you inherit its reputation without inheriting its operator: the payout wallet resets, the track record travels with the token, and nothing in the standard tells counterparties the operator changed. Months of good behaviour become an asset that can be quietly sold to whoever plans to spend it. This is not a bug in the implementation; it is what identity-as-token means.
MintID’s credentials are bound to the holder and cannot be transferred at all — if keys are lost, the only path back is re-verification with the issuer. Nobody can buy a track record, because there is no track record for sale: the thing a counterparty verifies is not history but backing — that a KYC-verified, liable human at a stated assurance grade stands behind this agent, right now, within a delegated scope. Backing is checked fresh at every encounter, so there is nothing accumulated to hijack.
Reputation is a vector, not a score
The sharpest critiques of ERC-8004’s reputation layer come from its own discussion thread. One contributor notes that a single aggregate score “facilitates monopolistic behaviour”. Another objects that trust is not a universal value of Bob, but a vector from Alice to Bob — my trust in an agent should not be your trust in it. The specification itself leaves open who filters the feedback and how, which in practice delegates the hard part to off-chain aggregators.
MintID agrees with the critics — structurally. There are no scores, no global identifiers to score against, and no on-chain feedback: the protocol normatively excludes a reputation registry. What a verifier gets instead is a pairwise pseudonym: stable enough for that verifier to recognise a returning agent, useless to anyone else, and rotated at renewal so no long-term dossier forms. Trust stays a vector from one verifier to one agent — identification, not surveillance. The trade is explicit: MintID gives up the public directory and the shared five-star rating to make cross-verifier correlation impossible; ERC-8004 gives up unlinkability to offer both.
Validating the work vs validating the backing
ERC-8004’s Validation Registry answers “was this output correct?” — by re-execution with stake at risk, or by TEE attestation. MintID deliberately does not answer that question. What it validates is the presentation: a zero-knowledge proof, bound to a fresh nonce, the verifier’s exact origin, the requested policy and the current issuer state root, delivered in about ten seconds and impossible to replay. It proves who stands behind the agent — not whether the agent did the job well.
These are orthogonal, and they compose. A serious counterparty wants both answers: ERC-8004 tells you whether the agent did the work correctly; MintID tells you who answers, and with what funds, if it didn’t. Neither substitutes for the other — re-executing a task says nothing about who is liable for it, and proof of a liable human says nothing about output quality.
When something goes wrong
Here the gap is widest. ERC-8004 places incentives and slashing outside the standard: validators may stake through external protocols, but the standard itself gives a harmed counterparty no path to compensation. Feedback is the remedy — you can warn the next buyer.
For MintID, recourse is the point of the design. Money comes before identity: disputes settle first against self-custodied escrow, then against the issuer’s slashable bond, with arbitrators drawn by lot and themselves bonded — and only at the top of the escalation ladder, under a certified due-process finding, does the issuer reveal who the human behind the agent is. Most victims want their money back, not a name; the cascade is ordered accordingly. An anonymous NFT owner can abandon a burned identity and mint a fresh one. A bonded issuer and a re-KYC-only credential cannot walk away that cheaply.
Complementary, not rival
ERC-8004 pluggably supports multiple trust models — reputation for low stakes, crypto-economic validation for medium, TEE attestation for high. Nothing prevents a fourth: human-backed. The registration file’s trust-model field is extensible, and an ERC-8004 agent offering services can declare that it supports MintID verification — any counterparty then obtains the Know Your Agent proof in the standard ten-second flow, re-verified live rather than read from a registry. Discoverability from their side, accountability from ours; the agent stays browsable as an NFT while its human backing stays private and non-transferable.
The one-sentence synthesis: ERC-8004 solves discoverability and externalises trust; MintID solves accountability and externalises discoverability. They answer “how do I find an agent and see what people say about it”; MintID answers “who is liable, with what money, if this agent harms me”.
Which one fits your use case
Use ERC-8004 if you need agents that are publicly discoverable today, want portable feedback and work validation, and are comfortable with pseudonymous operators — it is deployed, composable and has real ecosystem momentum.
Watch MintID if your requirement is a verified human behind every agent without building a surveillance layer: no public agent registry, no transferable identity, no correlatable feedback trail — and a funded path to compensation when things go wrong. MintID is a research-stage protocol: there is no live token and no mainnet before independent audits, and nothing in this article is investment advice.
The primitives behind MintID’s side of this table — the ten-second presentation, delegated agent scope, assurance grades — are laid out on the technology page and in the protocol spec.