What is an agent passport?

A passport is not a claim you make about yourself. It's issued by someone other than its holder, and its value comes entirely from that fact: a stranger at a border can check it independently, without taking your word for anything. An agent passport borrows that shape for a newer problem, software that acts on its own, autonomously trading, hiring other agents, paying for API calls, where the basic question "who's actually behind this, and does it have any track record?" otherwise has no reliable answer.

"Agent passport" isn't the name of one ratified specification. It's the plain-English label the AI-agent field has converged on for a pattern: give an autonomous agent a portable, checkable identity that outlives any single platform, so an outsider can look it up and decide for themselves whether to trust it, rather than trusting the agent's own description of itself.

The mechanism the field converged on

The concrete implementation most of the field has actually built toward is ERC-8004's Identity Registry, an ERC-721 NFT minted per agent, whose tokenURI points to an off-chain manifest describing what the agent is and who controls it. Minting the NFT is cheap and mechanical; the identity claim it anchors is what matters. What is ERC-8004? covers the standard itself (its three registries, who wrote it, where it runs) in full; this page takes that mechanism as given and asks what "passport" adds to it.

An ERC-8004 passport being third-party-checkable is the whole point: an independent registry, not the agent, is the one asserting "this identity exists and this address controls it." Anyone can query the registry directly and get the same answer Solidus would give them, without trusting Solidus's account of it.

Not the same thing as an A2A AgentCard

This is the one distinction worth getting exactly right, because it's easy to conflate two genuinely different patterns that happen to share vocabulary. Google's Agent2Agent (A2A) protocol also has an "AgentCard", a JSON document an agent serves about itself, at a well-known URL, for capability discovery. It answers "what can this agent do and how do I talk to it," and it's self-declared: the agent's own claim about itself, with no independent party vouching for it.

An ERC-8004 passport answers a different question, "who owns this identity, and can I verify that independently", and it's third-party-checkable by construction: the assertion lives in a registry the agent doesn't control. The two can compose. An on-chain passport can point to an off-chain AgentCard as part of its manifest, letting a lookup chain from "here's a checkable identity" to "here's what it says it can do." But they're answering different questions, and neither substitutes for the other. A self-declared capability list is not made third-party-checkable just by being referenced from a passport, only the passport's own registry entry has that property.

Agent Card and Agent Passport in the Lexicon carry this same distinction if you want the reference-length version.

Solidus's worked example: token 8064

Its tokenURI resolves to a JSON manifest Solidus calls a "SolidusAgentCard", its own name for the format, borrowing the "Card" convention loosely from A2A without being the same artifact.

One live discrepancy is worth stating plainly rather than smoothing over: the SolidusAgentCard JSON has, at times, described its DID method's registry status as "submitted... under review, not yet registered." That line is stale where it still appears, did:solidus is registered in the W3C DID Method Registry, confirmed 2026-07-04. Never "a W3C standard", registration in the method registry is a narrower, checkable claim than that, and it's the one that's actually true. Check the live card's wording against this fact before repeating it; a manifest can drift out of sync with reality faster than the copy describing it does.

Token 8064 is a worked example of the general pattern, not evidence of a fleet. One passport exists.

Checking it yourself

None of this asks for trust. The verification steps, the eth_call against the Identity Registry for ownerOf and tokenURI, and resolving the did:solidus identity the card names, live on Verify the agent passport. Run them against Base Sepolia's public RPC directly and you'll get the same answer without taking Solidus's word for any of it, which is, after all, the entire reason a passport is worth having.