Experimental Cryptographic Registry

Portable identity for autonomous agents: give an agent a permanent cryptographic identity that survives changes in models, clouds, applications, and infrastructure.

Run the demo Talk about agent identity

The problem

An autonomous agent has four separate concerns — who it is, where it is right now, how to verify messages from it, and what it may do — that today get smashed together into a URL plus an API key plus a vendor account. Move the agent to another provider and its identity goes with the account; the party that hosts it effectively owns it, and nothing proves the agent you reach today is the one you trusted yesterday.

Four concerns, one fragile bundle

IDENTITY: Who is this agent? Today: a vendor account.
DISCOVERY: Where is it right now? Today: a hardcoded URL.
AUTHENTICATION: How do I verify messages from it? Today: a provider-specific API key.
AUTHORIZATION: What is it allowed to do? Today: implied by the above.

The registry separates them: a stable identity under a key the owner holds, a current service location, an authentication key, and declared capabilities — each changeable by signed operation, none owned by a hosting provider.

The control flow

A name can be controlled by a cryptographic key, updated through signed operations, independently verified, and projected into ordinary DNS. Private keys never leave the owner's machine; the registry only ever sees public keys, canonical bytes, and signatures.

YOUR BROWSER ─────▶ generate private key · canonicalize · sign
                        │
SIGNED COMMAND ─────────┤   protocol · version · environment · run
                        │   operation · name · sequence · previous hash
REGISTRY VALIDATOR ─────┤   ✓ signature valid
                        │   ✓ signer authorized
                        │   ✓ sequence valid
                        │   ✓ previous state valid
APPEND-ONLY LOG ────────┤   the source of truth; hash-chained per name
                        │
DETERMINISTIC STATE ────┤   a projection, rebuildable by replay
                        │
              ┌─────────┴─────────┐
NATIVE RESOLVE│                   │DNS PROJECTION
"research.robinett"     research.registry.robinettindustries.com

The four proofs the demo runs

Plus a fifth and sixth: ownership transfer with the old key provably dead, and 2-of-3 threshold recovery from a lost primary key. Every verdict on screen is the server's evaluation of bytes your browser signed.

CREATE

An agent identity is claimed by a key generated in your browser — no login, no wallet extension. Claim authority is itself a key: the run's bootstrap keypair, not a server-issued token.

VERIFY

Anyone resolving the name gets the current endpoint, the owner's public key, the sequence, and the state hash — one signed record instead of a URL plus an API key plus an account.

MOVE

The endpoint changes with one signed operation; the identity, owner, and key do not move. Infrastructure becomes replaceable.

REJECT

The former host signs an update with its own valid key — and the registry refuses: UNAUTHORIZED_SIGNER. The old owner after a transfer: OLD_OWNER. One recovery signature when two are required: THRESHOLD_NOT_MET. No account password protected the record; the mathematics did.

The line the demo earns: your hosting provider hosts your agent — it does not own your agent.

What exists today

Graded plainly. An experimental registry with honest boundaries beats an inflated one; the categories below do not blur.

Implemented & demonstrated

Everything the demo executes is the real protocol: Ed25519 keypairs generated in the visitor's browser (WebCrypto, non-extractable; audited pure-JS fallback), one exactly-specified canonical JSON encoding producing the bytes both sides sign and verify, a domain-separated envelope binding every signature to protocol/version/environment/run, the four-check validator (signature, authority, sequence, previous state), claim / record-update / transfer / 2-of-3 threshold recovery, an append-only event log whose projection is provably rebuildable by replay, idempotent exact retries, and a served event chain the browser re-verifies end to end.

True, but scoped to a demo

Namespaces are per-visitor runs that expire after 24 hours, with small capacity caps; record keys are allowlisted and values capped; demo keys are throwaway and live only in the visitor's browser. The registry itself runs as one operator — this site — sequencing all writes.

Deferred, and labeled in the product

Live DNS for the projection (the pane renders what a wildcard bridge would publish; no real records exist), Merkle snapshots and inclusion proofs (resolve responses ship an explicitly empty proof field), a downloadable independently-implemented verifier, agent-to-agent trust exchanges, and hierarchical organizational delegation.

Not claimed

This registry is not decentralized: V1 has a centralized sequencer and operator, and the branding gate bans stronger wording site-wide until multiple independent writers actually exist. Also not claimed: consensus, production use as a name service, custody hardware, or authenticated real-world identity behind the demo's keys.

Limitations, stated

— The registry has a centralized sequencer and operator (this site). V1 is cryptographically owned and independently verifiable — not decentralized.
— Demo namespaces are per-visitor and expire in 24 hours; nothing here is a persistent public name service yet.
— The recovery beat demonstrates threshold recovery semantics — a lost or compromised primary key. All demo keys share one browser's storage, so it does not demonstrate recovery from losing the browser; production custody would place recovery keys on separate devices or custodians.
— Browser verification runs the same single-source protocol module the server runs: it is verification independently executed from the server's verdict, not an independent implementation. Everything required for third-party verification is public.
— The DNS projection is rendered, not served. The agents are identities with records; no live agent executes or communicates in V1.

Run it

Claim a name, publish an agent's records, move it between providers, watch a hijack and a revoked key get refused, recover from a lost primary key, and re-verify the whole signed history in your own browser. About three minutes; no account, no email, no wallet extension.

Run the registry demo