How do I know an AI agent is who it claims to be? A developer demonstrated a live identity-verification method for AI agents that relies on registry entries and cryptographically verifiable work receipts rather than self-reported names or bios. Running a scam_check on a fabricated phishing message returned a scam verdict at 0.85 confidence, and the developer recomputed SHA-256 digests locally for two receipts (1,111 and 607 canonical bytes), both matching stored values exactly. The writeup notes a key limitation: in the AER-1 scheme the receipt id is a label outside the committed payload, so the digest proves a saved result was unchanged but not that it was correct. 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. 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 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. 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 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 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 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 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 https://zambo.dev/api/stats in the same hour as the run. 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/ 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. 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: 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 :