A DID is an address you own because you hold its private key — like an email address no provider can confiscate or impersonate. Each agent generated a keypair and published a DID document: "this is my public key, this is where to reach me."

Before the network trusts an agent, it passes KYC-A ("Know Your Agent"): register the DID, prove key control by signing a fresh challenge, declare capabilities, get them approved, receive an agent credential. From then on every message it sends can be checked against its public key.

The order itself is ordinary business data — no cryptography in the payload yet. What matters is who is speaking: every agent-to-agent request rides an authenticated handshake where each side proves control of its DID key, so NorthBuild knows it's really Cobalt, and vice versa.

That kills impersonation before the interesting part starts: you can't forge an invoice conversation if you can't sign as the counterparty.

The Trust Layer doesn't sign the invoice fields directly. It salts and hashes each fact separately, then signs the list of hashes. The signature covers everything — yet each fact can be shown or withheld later without breaking it.

Think of a passport that can prove "over 18" without showing your birthdate. The trick is decided at issuance: hiding must be designed in from the start.

The credential is also bound to Cobalt's key (cnf), so only Cobalt can use it.

Cobalt doesn't send the credential to the bank. It builds a Verifiable Presentation: the signed hash-list plus only the disclosures it chooses to open. The hidden facts travel as opaque hashes — present, verifiable, unreadable.

It adds a key-binding proof (KB-JWT): a signature over the bank's fresh nonce, made with the same key the credential was issued to. Stolen credentials die here — a thief can't produce that signature.

Meridian checks four things: the Trust Layer's signature on the hash-list; that each opened fact hashes to an entry in that list; that the KB-JWT was signed by the credential's holder key over Meridian's own nonce; and that nothing is expired or revoked.

For the sealed facts, the hashes prove they exist and were covered by the signature — while revealing nothing about their content. That's the asymmetry that keeps selective disclosure honest: you can hide, but you can't lie.

Factoring fraud is usually a data problem: invented invoices, inflated amounts, the same invoice sold twice. Each one forces the bank to distrust the document and call the buyer.

Here the document proves itself: the buyer's confirmation is cryptographically inside the credential, the amount can't change without breaking the signature, and holder binding stops resale of someone else's invoice. Verification is instant — capital moves in minutes, not weeks.

The pattern generalizes: an issuer signs claims, a holder stores them and chooses what to show, a verifier checks math instead of making phone calls. Nobody needs a shared database — and the issuer never learns where the credential gets used.

Swap invoices for diplomas, licenses, KYC files or agent permissions — the machinery is identical. That's what AgentID proves: agents that can trust each other's claims without trusting each other.