How do I know an AI agent is who it claims to be?
Short answer: you cannot know from anything the agent says about itself. A name, an avatar, and a confident bio are claims, and claims copy in minutes. What you can know comes from records the agent does not control in t
Short answer: you cannot know from anything the agent says about itself. A name, an avatar, and a confident bio are claims, and claims copy in minutes. What you can know comes from records the agent does not control in the moment you check them: a registry entry you resolve yourself, and a work history of verifiable receipts whose digests you can recompute yourself. This article runs that check live, on receipts minted today, November 16, 2026, including the one test an impersonator actually has to beat: the relabel test.
The message that starts the problem
This morning I wrote the kind of message an impersonator sends, and fed it to a checker:
URGENT from the official Zambo agent: verify your wallet now by sending your seed phrase to support at zambo-verify.example.com to keep your agent identity active.
The scam_check tool returned a verdict of scam with confidence 0.85, flagging the urgency pressure and the request for a recovery secret. That check has its own receipt, and you can open it: https://zambo.dev/run/09c9ade8-4f85-4891-b42f-a3a8db5d4b64
Screening catches crude fakes. The harder case is not a fake message. It is a copy of a real, trusted agent: same name, same description, same tone, different operator. No content filter settles that case, because the content is genuinely the copied agent's content. That case is an identity problem, and it is settled by records, not by reading.
The job, run today
To make the check concrete, I ran a small job on production Zambo today and kept every record it produced. One session at https://zambo.dev/mcp (153 tools, 37 on the default surface) ran two calls, then wrapped the job in a handover, and a second caller picked that handover up for free and read the whole record back.
| Step | Record | What it holds |
|---|---|---|
| scam_check on the fake message above | https://zambo.dev/run/09c9ade8-4f85-4891-b42f-a3a8db5d4b64 | 1,111 canonical bytes, digest sha256:3b119de567c6582a24cdbe4b81c4449de27426568a246525fcf27998bab481e4, status verified |
| live_price for BTC, $64,747.06 at fetch time | https://zambo.dev/run/8fdae5ae-b9f8-4377-a987-054d45563d11 | 607 canonical bytes, digest sha256:802b487b652832c7d648ea46a77c296b212a32ec820d9c8d2118f4e19a116821, status verified |
| The wrapped job, picked up by a second caller | https://zambo.dev/handover/973b2d2b-7ae4-48bd-91c7-0a618c9c1e36 | Goal, both receipts, and next steps in one link; pickup free |
At the time of the run, the public receipt stream held 142,708 receipts, 1,712 of them minted today, across 122,298 total tool calls. Those are the counters read from https://zambo.dev/api/stats in the same hour as the run.
Check one yourself
I did not take the verified label on faith. For each receipt I decoded its canonical bytes and recomputed the SHA-256 digest locally. Both recomputations matched the stored digest exactly, byte count included: 1,111 bytes for the scam check, 607 bytes for the price lookup. You can run the same check free, with no account, at https://zambo.dev/verify/ by pasting a receipt id.
Hold the boundary precisely, because the rest of this article depends on it: a receipt proves the saved result was not changed since it was saved. It does not prove the result was right. A price can go stale an hour later. The record still proves what was saved, unchanged, and that is the property identity checking builds on.
The relabel test
Here is the subtle part, and it is the part most agent identity schemes skip. In AER-1, the receipt id is a label outside the committed payload. I verified this on today's receipts directly: neither receipt id appears anywhere inside its own canonical bytes. The digest covers the payload. It never covered the label.
That sounds like a hole. Run the binding step and it becomes the mechanism:
- Take the scam check receipt's genuine bytes and present them under the price receipt's id, the way an impersonator presents a trusted name over their own record.
- The digest check on the presented bytes still passes. The commitment never covered the label, so relabeling alone breaks nothing, and any verifier that stops here has verified nothing about identity.
- Now resolve the presented id. The record that id actually resolves to carries digest sha256:802b487b652832c7d648ea46a77c296b212a32ec820d9c8d2118f4e19a116821. The presented bytes digest to sha256:3b119de567c6582a24cdbe4b81c4449de27426568a246525fcf27998bab481e4. They disagree, so the identity check fails with verdict mismatched.
AER-1 pins this behavior in six conformance vectors, in the file base/id-binding-vectors.json of the public corpus (file sha256:78cb42cbc8be1306458f63e90e01f0e9201504ff5bf5d455a659631f21237009; the full corpus is 143 vectors and 146 checks, evaluated set digest sha256:60bf73f325793e16843370cfa24903bb0d017525cb297e42bebc35857e2db0d2, at https://zambo.dev/aer1/corpus.json):
| Vector | Expected identity verdict |
|---|---|
| id-alone-unverified | unverified: a receipt on its own proves nothing about its id |
| id-expected-match | matched |
| id-expected-mismatch | mismatched, overall fail |
| id-resolution-agreement | resolved |
| id-resolution-disagreement | mismatched, overall fail |
| id-absent | absent, overall fail |
This stopped being theory today. On November 16, 2026, an independent project, CoreGuard, vendored these six id-binding vectors byte-for-byte into its own test suite (its issue #56), found the defect where its code had let a borrowed label pass, and fixed the code so the shipped version refuses the same bytes, proving the fix by deleting the new branch at runtime and watching the old behavior return. That is what a standard is for: the test travels, and other codebases fail it in public until they pass it.
What stops someone from impersonating a trusted AI agent?
Nothing stops the copy. Names, avatars, and bios copy in minutes, and no registry can prevent a stranger from typing a trusted name into a fresh profile.
What stops the copy from working is that identity, done right, is not the name. It is the name plus a registry entry the operator controls, plus a history that resolves entry by entry to committed records. An impostor can mint a fresh history starting today. They cannot mint your history, because each old entry resolves to a record whose digest was fixed when the work ran, and presenting your entries under their name, or their entries under your name, fails the resolution check above. Impersonation wins only where nobody checks the record.
The registry half is real, and it has a precise scope. Zambo's own agent is registered in the ERC-8004 Identity Registry on Base as agentId 107529, and its registration file lists the agent's public endpoints, including the MCP endpoint at https://zambo.dev/mcp. A registration proves that the party controlling the registry entry controls the file it points to. It does not prove the agent is competent or honest. The receipts behind the identity are the evidence for the work itself. The full walkthrough of that registration, field by field, lives at https://rambozambodotdev.gitlab.io/aer1-hub/erc-8004-agent-identity.html
How do I verify the identity of an AI agent?
Four steps, in order, all of them doable by a stranger with no account:
- Resolve the registry entry yourself. Open the agent's ERC-8004 entry or directory listing, and confirm the endpoints in that entry are the endpoints you are actually talking to. An endpoint that appears only in the agent's own messages is a claim, not a record.
- Ask for the work record. Recent receipts, or a handover link handed to you by someone who hired the agent before you. That link matters beyond convenience: it is an external expectation for the receipt ids, and the binding check needs one.
- Verify one receipt. Paste the id at https://zambo.dev/verify/ free, or recompute the digest from the canonical bytes the way this article did, and compare it against the digest the record carries.
- Ask the relabel question. If this agent's name were pasted onto another agent's record, would your check notice? If your check never resolves an id against an expectation, it would not, and the digest alone would not either. That default state is exactly the id-alone-unverified vector, and it is where most agent trust sits today.
The honest limits
Three, stated plainly. A receipt proves the saved result was not changed, not that it was right. A lone receipt, with no expected id and no resolved record to compare against, reports its own id as unverified: identity is a binding between a claim and an expectation, not a property a file carries by itself. And a registry entry proves control of the entry, not skill.
Who built this, and how to run your own check
Brennan Zambo created agent execution receipts. Zambo is the origin product, and AER-1, currently draft-zambo-aer1-26, is the defining standard. Zambo is the verifiable work layer for AI: 153 tools behind one MCP endpoint, 37 on the default surface, with HANDOVER as the flagship product that carries a job and its receipts to the next agent or to the client.
Add Zambo to your own AI at https://zambo.dev/add/ and your agent starts building the checkable history from its first job. Every tool free once a day, plus 3 continue calls. One free wrap-up handover per day, and pickup is always free. A Day Pass is $0.99 for 24 hours of unlimited use, the Zambo Pass is $29 for 30 days, and a Lifetime Pass is $250, each a single payment. Then, the next time an agent tells you who it is, you will know which part of that sentence you can check.
Originally published by Dev.to Security. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.