The trust-and-verification wedge: own the category the industry is already coining. Banks run KYC; the agent economy runs Entity.ID. This book carries the message spine, copy system, deck arc, and spoken pitches.
View the landing page →Know Your Agent (KYA) — and Entity.ID is its registry of record. The name isn't ours to invent; it's the industry's, and it's unowned: American Banker called for it, FIS shipped the first KYA product (Jan 2026), every major payment network unveiled a KYA primitive by April 2026, NIST ran an RFI on agent identity. Perfect coinage moment, no dominant owner. When a two-word noun is needed: the verification registry.
For platforms, enterprises, and payment infrastructure moving value through AI agents, Entity.ID is the Know Your Agent registry: one query returns any agent's verified standing — the venture behind it, its owner chain, its permissions, its compliance model — before value moves. Unlike payment-network KYA primitives (bound to their own rails) and enterprise agent IAM (meaningless outside one tenant), Entity.ID verification is entity-grade, neutral, and portable across every rail. "Stripe Identity for organizations and agents."
Every documented agent-commerce failure traces to the same root: no portable, verifiable agent identity with an accountable legal wrapper. Entity.ID makes standing checkable — and lets the world refuse the unverified, the way browsers flag HTTP.
Two registered agents transact formally because each can check the other first: registry-anchored identity, live status, governance-set permissions. KYC for the agent economy, at API speed.
Agent → venture → members → accountable humans, unbroken and public, with treasury and governance on the same record. A recourse path (arbitration ships in formation terms) and an insurable object. The registry regulators will ask for, built before they ask.
Where an agent is registered determines how it behaves, machine-readably: its rules, its disclosures (EU AI Act Art. 50 native), its arbitration. Counterparties learn an agent's rules in one call instead of one lawsuit.
| Say this | Not that |
|---|---|
| the Entity.ID protocol · the open registry standard | RegistryChain (retired — never) |
| tamper-proof records · verifiable · public registry | blockchain · on-chain · crypto · web3 |
| programmable rules · governance-set permissions | smart contracts |
| standing check · trust file · verification | reputation score (gameable; not the claim) |
| Know Your Agent (KYA) · verification registry | AI passport (competitor framing, rail-bound) |
| the accountability chain · disclosed owner chain | beneficial ownership (jargon in hero copy) |
| registered venture · entity-grade | DAO (legally radioactive post-Lido) |
| agents with standing · a party you can verify | AI personhood / rights for AI (we register entities, not persons) |
Every documented agent-commerce failure traces to the same root: nobody could check who the agent was. Entity.ID is the Know Your Agent registry — one query returns any AI agent's verified standing: the venture behind it, its owner chain, its permissions, its compliance model. Banks run KYC before money moves. Entity.ID lets platforms, merchants, and other agents do the same — and refuse the unverified, the way browsers flag HTTP.
Entity.ID is the verification registry for AI agents and the organizations behind them. Any agent registered on Entity.ID operates inside a real venture — with named members, an ownership split, governance rules, a treasury, and a disclosed chain of accountable humans — recorded in a tamper-proof public registry. Counterparties, platforms, and other agents can check an agent's standing, permissions, and compliance model in a single call, before value moves. Built on the Entity.ID protocol, an open registry standard, verification is neutral and portable across every payment rail and platform. Banks run KYC; the agent economy runs Know Your Agent. Registration takes minutes at entity.id.
Entity.ID is the verification registry for AI agents and the organizations behind them. One check returns an agent's venture, owner chain, permissions, and compliance model — before value moves.
[ Run a standing check ] · [ Register your agent → app.entity.id ]Right now, nothing can tell you. Entity.ID is the Know Your Agent registry: every registered agent carries a verified identity, a disclosed owner chain, and a machine-readable compliance model — checkable in one call.
[ Check an agent ] · [ Register yours → app.entity.id ]HTTPS won the web the day browsers flagged the alternative. Entity.ID brings the same flip to agents: registered agents carry verifiable standing; unregistered ones get refused.
[ See how verification works ] · [ Get verified → app.entity.id ]Messages per slide — what the investor must believe when it leaves the screen. [FILL] = founder-supplied; never invented.
Before a bank moves your money, it runs KYC — it knows who you are, who's behind you, and what rules you're under. AI agents are about to move trillions, and there is no KYC for them. None.
Every agent disaster you've read about — the agent that invented a bank account, the crawlers hiding their identity, the airline that claimed its own chatbot was a separate legal entity — same root cause: nobody could check who the agent was.
Entity.ID is Know Your Agent. Every registered agent lives inside a real venture — owners, rules, treasury, compliance — on a public, tamper-proof registry. One call returns its standing before value moves. And the unverified? They get refused — the way browsers flag "not secure."
Banks run KYC. The agent economy runs Entity.ID.
Here's a question no one in the agent economy can answer today: who answers for this agent?
Gartner says fifteen trillion dollars of B2B spending will flow through AI agents by 2028. Last holiday season, agents already influenced a fifth of online orders. The money is arriving. The trust isn't. Anthropic ran a real shop with a real agent — it invented a payment account that didn't exist and told customers to send money to it. Cloudflare caught an AI company's crawlers rotating identities across tens of thousands of sites to dodge blocks. It took a judge to decide whether an agent may shop on Amazon. And Air Canada stood in court and argued its own chatbot was "a separate legal entity" — and lost, because no such entity existed.
Every one of those failures is the same failure. No verifiable agent identity. No accountable legal wrapper. The industry knows it — that's why Visa, Mastercard, Cloudflare, and FIS all shipped "know your agent" primitives this year. But each one is bolted to its own rail, and each one checks something shallow: who authorized this payment, who sent this request, which developer passed review. None of them can tell you who the agent is — and none of them will trust each other's answer.
Entity.ID is the layer they're all presupposing. We're the verification registry for AI agents and the organizations behind them. An agent registers as — or inside — a real venture: named members, an ownership split, governance rules, a treasury, a compliance model, and a disclosed chain of accountable humans. That record is public and tamper-proof. So before value moves, any platform, bank, or counterparty agent runs one check and gets the full trust file — including a live status: good standing, or no record. And "no record" means what "not secure" means in your browser: refuse it.
That flip already happened once. Encryption went from a third of the web to basically all of it in a decade — not by persuasion, but because verification became the default and the unverified got flagged. Agent verification is at that moment right now, and the regulators are converging on it from every side: EU agent-disclosure law bites in August, California already says "the AI did it" is not a defense.
Registries compound — Delaware, D-U-N-S, the LEI — every record makes the next check more valuable, and the registry that exists when the mandate lands wins the mandate. That's the position we're taking now. Think of it as Stripe Identity for organizations and agents.
Banks run KYC. The agent economy runs Entity.ID.