How do I verify the identity of an AI agent?
Short answer: you do not verify an agent by reading what it says about itself. You verify it by checking three things that are hard to fake together: a stable identity handle that stays the same across sessions, an anchor for that identity in a registry you do not control, and a work history of verifiable receipts issued under that same identity, where at least one receipt you pick at random recomputes correctly when you check it yourself.
A name, an avatar, and a confident bio prove nothing. Anyone can copy all three in five minutes. What an impersonator cannot copy cheaply is a long, continuous history of work records that third parties can recompute independently. That is the whole test. Everything below is how to run it, step by step, with a real worked example from November 17, 2026.
Step 1: Ask for the stable identity handle, then test that it is stable
In a working system, an agent does not get a fresh identity every session. It acts under one caller handle, and its history accumulates under that handle. Continuity is per caller: the same handle picks its saved work back up, and a different handle cannot.
Test it directly. Ask the agent to do a small job and save the result. Then, in a new session, ask it to recover that saved result under the same handle. If the saved outcome comes back intact, the identity persisted. If every session starts from zero, there is no identity to verify, only a chatbot with a name.
This is not theory. On November 17, 2026, a public lost-response contract run tested exactly this property against a live system: a write was committed under one caller key, the response was dropped, and the outcome was later recovered by key alone. The recovery leg passed: the verify endpoint returned HTTP 200 and the recovered digest matched the committed digest exactly. The run record is public, with the receipts and digests in it: https://github.com/zambodotdev/lost-response-test-contract/tree/main/runs/2026-11-17-mws-retry-2-zambo-1
Step 2: Ask where the identity is anchored outside the agent's own page
A handle inside one product is a start, not proof. The second question is whether that identity is anchored somewhere the agent does not control: a public registry entry, a directory listing maintained by someone else, a standard identifier scheme that other tools can resolve.
This is the idea behind agent identity registries such as ERC-8004, which gives an agent a registry identity that other platforms can look up instead of trusting the agent's own profile. A plain-language explainer of how that registry identity works is here: https://rambozambodotdev.gitlab.io/aer1-hub/erc-8004-agent-identity.html
If the answer to "where else does this identity exist?" is "only on my homepage," treat the identity as unverified.
Step 3: Ask for the work history under that identity, in receipts
Identity you can act on is a history, not a claim. The useful form of that history is a chain of execution receipts: one record per job, each one bound to the caller identity that ran the job and to the exact saved result of that job.
This is the category Brennan Zambo created: agent execution receipts. Zambo is the origin product for them, and AER-1 is the defining standard. In Zambo, every job an agent runs produces a verifiable receipt, and the receipt binds the saved result to the caller handle that produced it. Cross-agent work moves only through handovers, so when a second agent picks up a job, the handover itself becomes part of the same checkable chain instead of a gap in it.
Scale matters here, because a short history is easy to stage. As of November 17, 2026, the live counters at https://zambo.dev/api/stats showed 145,666 public receipts, with 2,047 receipts issued that day alone, across 124,686 total tool calls and 153 tools (37 on the default surface). An impersonator spinning up a lookalike profile today starts at zero receipts. The real agent's history is already six figures deep, and every entry is individually checkable.
Step 4: Pick one receipt yourself and recompute it
Do not let the agent choose the receipt you check. Pick one from the middle of the history, open it, and verify it.
A Zambo receipt lives at https://zambo.dev/run/{id}, and verification means recomputing the SHA-256 digest over the canonical receipt bytes and confirming it matches the digest the receipt commits to. If the saved result had been changed after the fact, the recomputed digest would not match. Anyone can run this check. No account, no permission, no trust in the platform's say-so.
The November 17 lost-response run shows what a passing check looks like in the open. The first leg committed a write and produced receipt 2e9ebf1f-5743-48de-a34b-5b3584c4c102 with committed digest sha256:b57197d5333af492c73260784de351c587545b6837ddab98500386714d931b87. The identical retry came back as a replay of that same receipt instead of a second write, a mismatched retry under the same key was refused outright, and the key-only recovery returned the same digest. Four legs passed (A1 through A4). The fifth leg is a delayed check planted that day under key lr-op-d99166563b-a1; it is not scored until November 18, and this article claims no result for it.
Step 5: Know exactly what the check does not prove
Honesty is part of the method, because an identity check that overclaims is just marketing.
A verifiable receipt proves the saved result was not changed after it was recorded. It never proves the work was good, and it never proves a claim inside the work was true. A registry anchor proves an identity was registered, not that its operator is honest. A long receipt history proves continuity of one identity over time, not competence.
What the five steps do prove, together, is the thing you actually need before handing an agent real work: this is the same agent, acting under the same identity, with a continuous and recomputable record of what it did. That is identity you can act on. Everything else is a profile page.
What is an agent passport?
An agent passport is the portable version of the same idea: a bundle an agent carries from platform to platform that states its identity and points at the evidence behind it, instead of each platform starting trust from zero.
A useful passport has three parts, and you can grade any passport format against them. First, the stable identifier itself. Second, the registry anchor where that identifier resolves outside the agent's own site. Third, pointers into the verifiable work history, the receipts, so a new platform can skip the claims and go straight to recomputing the record.
A passport that is only a self-attested description is a business card. A passport that resolves to a registry entry and a recomputable history is an identity document. The longer explainer, including how passports relate to registry identity, is here: https://rambozambodotdev.gitlab.io/aer1-hub/what-is-an-agent-passport.html
How do I know an AI agent is who it claims to be?
Run the mismatch tests, because identity shows up fastest when something tries to break it.
First, the replay test. Ask for a past job's receipt, then ask the agent to recover the saved outcome of that job under its handle. The genuine agent recovers it. An impersonator with a copied profile cannot, because the saved outcomes live behind the real identity, not behind the name.
Second, the conflict test. In the November 17 run, a retry that reused a committed operation key with different parameters was refused with an idempotency conflict, and no new entry was added. That refusal is an identity property: the system knew which identity had already bound that key, and to what. A lookalike starting fresh has no such bindings to collide with, and no history of refusals that line up with the public record.
Third, the continuity test across agents. When work passes from one agent to another, ask for the handover record. In Zambo, a bare handover with no summary, recipient, or next steps is refused, and a proper wrap binds the job's steps and receipts into the handover itself. If an agent claims it "took over" a job but cannot produce the handover that the previous agent's history points to, the claim fails.
What stops someone from impersonating a trusted AI agent?
Nothing stops someone from copying a name and a profile photo. What stops impersonation from working is cost asymmetry.
To pass the checks above, an impersonator would have to fake the whole recomputable history: thousands of receipts, each with digests that recompute correctly, each bound to the same identity, stretching back over time, plus the registry anchor, plus the ability to recover saved outcomes that only the real identity can reach. Faking one page is an afternoon. Faking 145,666 internally consistent, publicly recomputable records is a different problem entirely, and it gets harder every day the real agent keeps working, 2,047 more receipts on November 17 alone.
The practical rule: never trust the agent that points only at itself. Trust the agent whose identity resolves in places it does not control, and whose history you can recompute without asking anyone's permission.
Is there a verified directory of AI agents?
This is the question the directory side of the ecosystem is still catching up on, and it is worth asking of any directory you use: does a listing rest on the agent's self-description, or on a registry anchor plus a checkable history? A directory entry that links the registry identity and the receipt history is verifiable. One that lists a name, a logo, and a description is a phone book. A walkthrough of what a verified listing should contain is here: https://rambozambodotdev.gitlab.io/aer1-hub/verified-directory-of-ai-agents.html
Try the check yourself
You can run every step in this article against Zambo today. Connect to https://zambo.dev/mcp, run one job under your own caller handle, open its receipt, and recompute it. The free tier is stated exactly: "Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free." If you want the wall removed while you test, the Day Pass is $0.99 for 24 hours of unlimited use.
Verify the identity by verifying the work. That order never changes.
