How to verify our ERC-8004 agent passport yourself

An agent's own word about itself isn't worth much, anything can claim an identity. What makes a passport useful is that a stranger can look it up independently and get the same answer Solidus gets. That's the entire mechanism below: two eth_calls against a public contract, one curl, one DID resolution. No account, no API key, no trust required.

The claim, as a checklist

Before any command runs, here's the verdict:

1. A specific Ethereum address owns ERC-8004 token 8064.
2. That token's tokenURI resolves to a real, live JSON document.
3. That document names a did:solidus identity that resolves live against Solidus's own RPC.

Read on only if you want to run it yourself.

Command 1, ownership

Call ownerOf(8064) on the ERC-8004 Identity Registry, deployed at 0x8004A818BFB912233c491871b3d84c89A494BD9e on Base Sepolia:

eth_call ownerOf(8064) → 0x8004A818BFB912233c491871b3d84c89A494BD9e (Base Sepolia)
  returns: 0xcdcfa8a7709796e13bc8bd9d86d3523933e3ede4

Any Base Sepolia RPC endpoint (e.g. the public sepolia.base.org) will return the same address. That address is the owner of record for token 8064: nothing here comes from Solidus's servers.

Command 2, the manifest

The same contract's tokenURI(8064) points to the off-chain manifest for that token:

eth_call tokenURI(8064) → same contract
  returns: https://agents.solidus.network/v1/agents/d7b2f0ed-a5ba-4c48-a3af-7c14e8070b20/card

That URL is a live endpoint on this domain: the chain, not Solidus's copy, is the one telling you where to look.

Command 3, the identity

Fetch what the chain pointed you to:

curl https://agents.solidus.network/v1/agents/d7b2f0ed-a5ba-4c48-a3af-7c14e8070b20/card

This returns a SolidusAgentCard JSON document, Solidus's own manifest format, naming the agent's did:solidus identity:

did:solidus:testnet:46Hzv2Ek4MXwj1Kenvix4tWCPr1J

Resolve that DID against the live rpc.solidus.network and it comes back, a real, currently-anchored identity, not a placeholder string.

One thing worth flagging rather than quietly fixing: the SolidusAgentCard JSON you just fetched describes did:solidus's registry status as registered in the W3C DID Method Registry. That is correct, and it did not always say so. For a stretch after the registration actually landed on 2026-07-04, the card still read "submitted... under review, not yet registered", and nothing in the pipeline noticed, because the field is free-form prose rather than a checkable status. Treat that field as a note written by a human, not a status you can rely on in either direction: the DID above resolves live regardless of what the card's own copy claims about its registry status.

The cross-check

This is the actual proof, and it's an agreement, not an assertion. The on-chain contract (Command 1) says who owns token 8064. The off-chain card that same contract points you to (Commands 2–3) independently names an owner and a DID. You didn't have to trust the card, the chain told you where to find it, and you didn't have to trust the chain's opinion of who's behind it, the card names an identity that resolves live, on infrastructure Solidus doesn't control the outcome of. Two independently-checkable sources agree. Neither half needed to be taken on faith.

What this is not

Stated as plainly as the proof above it:

• This is one agent, not a fleet. Token 8064 is the passport described above. The same owner address also holds token 8071, anchored during an outsider's own independent repro of this exact process: that's evidence the process is reproducible, not evidence of scale. There is no fleet of agents behind this.

None of that undercuts the proof above, it scopes it. The commands you ran are real and reproducible regardless of how small the current footprint is. That distinction, a real mechanism at small scale, versus an inflated claim at any scale, is the entire point of publishing a page that asks you to check rather than believe.

What ERC-8004 and "agent passport" mean beyond this one token

This page proves that one token works. It doesn't explain what ERC-8004 is as a standard, or what "agent passport" means as a general pattern beyond Solidus's implementation of it.

For the standard itself, who authored it, what its three registries do, where it's deployed, see ERC-8004 in the Lexicon. Solidus did not author ERC-8004 and doesn't claim to; the standard was proposed and refined by contributors from MetaMask, the Ethereum Foundation, Google, Coinbase, and over a hundred others across the Ethereum ecosystem.

For the general concept this token is one instance of, why "portable, third-party-checkable identity" matters for autonomous agents at all, and how it differs from a self-declared agent card like Google's A2A protocol uses, see Agent Passport.

Both of those entries cite the proof on this page as their receipt. If you've run the commands above yourself, you've already verified what they cite.