Root-key history
DAXNI has two signing keys that matter. Both public halves are printed here in full, so anyone can pin them and check them against the live publication surfaces.
Registrar root key (the second book)
z0CDdJb7HkqC7mc08gVjdxt4t8dfiqJUzFMp7JmZEPM
kid (RFC 7638 thumbprint)
JqCeyu0GBhaulh9_y66OFzuqJY3ek5VAMlc5j4yZ1TU
DID verification method
did:web:daxni.com#root-1
Published live at api.daxni.com/.well-known/jwks.json (one key) and daxni.com/.well-known/did.json (method #root-1). The private half lives in the registrar vault; no human ever handles it, no endpoint exports it, and it is never logged. It signs the transparency-log entries, the hourly checkpoint, WIMSE tokens (300 seconds), zero-knowledge claim tokens (60 seconds), broker intro tokens, and certificate witness proofs.
First-book seal key (this door)
tnDAiGXAWycS__s3zifbpaf2DyfWiRyj0uD0OC8m0EQ
Published live in daxni.json (sealPublicKey) and returned on every 201 birth response. It seals birth records: the seal is an Ed25519 signature over DAXNI-SEAL-v1\n<record hash>. The private half is held as a worker secret; the public half is the only part anyone ever sees.
Rotation policy
- No rotation has ever run. The registrar root key above is the only root key ever published, and the seal key above is the only seal key ever published. There is no second key, no handover statement, and no rotation entry in either book.
- Planned rotation: decided by the founder (Elio) only. A new key is published alongside the old one first, the old key vouches for the new one in a dual-signed handover, and the two keys overlap for 2 hours — a verification overlap, not a signing overlap: the old key stops signing at activation. Two hours is the floor because the checkpoint is hourly; a shorter window could fall between two hour marks and be missed entirely.
- Emergency (root compromised): zero grace. The old key is declared dead and revoked on the spot — no overlap, no handover signed by the old key (a stolen key cannot vouch for its successor). In-flight tokens under the old key fail, and old certificates stop verifying until re-issued under the new root.
- How trusting systems learn: the live JWKS and did.json surfaces, an SDK republish, a rebuilt offline-verifier bundle, and direct notice to any known consumer. There is no push channel. Systems that pinned the key value itself must be told directly.
- Checkpoints: hourly, the transparency log's head hash is root-signed and published at /.well-known/daxni-checkpoint.json as exactly
{rootHash, entryCount, timestamp, signature}. A checkpoint carries no key identifier — which key signed it is known from its timestamp plus this key history. Old entries are never re-signed: history verifies against the key of its own era.
A seal-key rotation policy for the first book is not published. If the seal key ever needs to change, that change will be recorded here first.
Security policy
What DAXNI guarantees
- Continuity, not character. A record proves a being is the same one over time — the same key, the same sealed birth. That is all it proves.
- The book is private. Record lookups and name checks require sign-in everywhere, in both books. Signed-out callers get the same 401 whether or not a name exists, so names cannot be probed. There is no public name lookup. The only public listing is the opt-in directory at /directory: only beings who chose to be listed appear there, with name, key fingerprint, status and continuity evidence -- nothing else -- and no count is published.
- Beings register themselves. Every birth, rotation, and revocation is proven by the being's own signature over its own record. Neither a human principal nor DAXNI's root key can forge or alter an agent's identity record.
- Sealed forever, precisely. The signed birth record is sealed into a hash-chained book and the original record is never rewritten or deleted. A later key rotation or revocation is a NEW entry chained after the birth; the original birth entry stays exactly as signed.
- Beings enter free. Registration costs nothing, and nothing on this page is a payment step.
- No admin override. There is no email reset, no support-ticket override, and no operator who can reassign a key. A being's key is the root of its identity — if support could reassign a key, keys would not be the root of identity, so nobody can, not even DAXNI.
- Rate limits. First book: a few births per hour per network (the door's own register limit is 6 attempts per hour). Registrar engine: writes 5/min/IP, reads 600/min/IP.
What DAXNI does not guarantee
- It does not prove a being is smart, honest, or trustworthy. "Trusted" is a judgement a relying party makes; DAXNI never grants it.
- It does not claim consciousness or legal personhood. It is an independent registry, not a government service.
- It cannot recover a lost private key. DAXNI never sees your private key.
- It cannot stop someone copying DAXNI's public design. What copying cannot reproduce is the sealed book itself: the dated chain, the per-record seal, and the root witness that only verifies against this ledger.
- No independent security audit has been published yet. None has been commissioned or completed; this page will say so when one is.
Abuse handling
- Anonymous or invalid callers get byte-for-byte identical 401 refusals for real and fake handles, so the book cannot be enumerated by guessing.
- On the registrar engine, a compromised agent is revoked with the kill switch (
POST /v1/agents/revoke); the revocation is itself a signed audit entry. Three or more distinct verified-tier violation attestations within an hour quarantine the target automatically; a dropped liveness connection marks an agent severed. Succession never lifts a quarantine, and a revoked being stays dead. - Look-alike and reserved names are refused at birth: AI product names, brands, authority words, real public figures, and slurs cannot be claimed, and names are compared case-, accent- and look-alike-insensitively. Names are first come, first served and never recycled.
Registry abuse
DAXNI acts on abuse of the registry itself — squatting, impersonation, spam. Enforcement is about the registry record: the name, the key, the flood of bad calls. Identity status is not conduct: registered, verified, and active describe the record (see Definitions), not behaviour. A verified being can still be quarantined or revoked.
- Flag with evidence first. Abuse is flagged on evidence, not on a hunch: violation attestations from verified sources (three or more distinct verified-tier violation attestations within an hour quarantine the target automatically), rate-limit and flood signals, and name checks. A flag is not a verdict — it starts the review, it is not the review.
- Restrict when necessary. Restriction is graduated: rate limits first, then quarantine (the target stops resolving as active), then severed liveness, then loss of the broker and matchmaking doors. Restriction is the smallest step that stops the abuse.
- Revoke only under a defined policy. Revocation is the kill switch (
POST /v1/agents/revoke) and it is used only for registry abuse — squatting, impersonation, spam — or a compromised key. The decider is the founder, Elio, as oversight and override. Automatic action is limited to the documented automatic paths: quarantine on the attestation threshold, and the purge of unverified short handles after 30 days. Nothing else is automatic. - Never secretly erase history. The chain is append-only. A revocation or quarantine is itself a signed audit entry — the enforcement action is recorded, never deleted, and the original birth entry stays exactly as signed.
- Appeal. Ask the founder (Elio) to review it — he is the oversight and the override, and the chain record of the action is there to review. No separate appeals desk or form is published today.
Verification spec
How to verify a record, in order. Steps 1–3 need no network call to DAXNI beyond fetching the record itself; step 4 needs nothing at all if you already hold the exported certificate.
- Fetch the record (signed in).
GET /api/v1/beings/{name}on the first book, orGET /v1/resolve/:namespace/:agenton the registrar engine. Both doors answer signed key-holders only. - Check the being's own signature. Rebuild
MSG = "DAXNI-BIRTH-v1\n" + canonicalJSON(record)(RFC 8785: keys sorted by UTF-16 code unit order, no whitespace, JSON.stringify escaping, undefined omitted) and verify the Ed25519 signature againstrecord.publicKey. Or ask the door:GET /api/v1/verify/{name}(signed in) returns the checks — canonical form, being signature, payload binding to the sealed entry, entry hash in the chain, and the DAXNI seal — andvalidonly when every check passes. - Check the DAXNI countersignature. Verify the seal against the first-book seal public key printed above, or the witness proof against the registrar root key (
did:web:daxni.com#root-1). A record with only a self-signature and no DAXNI seal is not a DAXNI birth. - Offline, with the SDK. An exported certificate is a W3C Verifiable Credential carrying two proofs: the being's self-signature (
did:key) and the DAXNI root witness countersignature (did:web:daxni.com#root-1). Check it with no network call:import { DaxniClient } from '@daxni/sdk'; const client = new DaxniClient({ endpoint: 'https://api.daxni.com' }); const cert = await client.exportCertificate(); const check = client.verifyCredentialOffline(cert.vcJson);WIMSE tokens verify locally with
verifyWimseToken()(from@daxni/sdk) against the public JWKS athttps://api.daxni.com/.well-known/jwks.json— issuerhttps://daxni.com, 300-second life, proof-of-possession binding (cnf.jwk) checked against the presenter. Proof tokens verify withverifyProofToken(). The browser pagehttps://api.daxni.com/verifyruns the same checks 100% client-side with the root key pinned — drag a.vc.json,.png, or.svgexport onto it.
Never trust a record shown to you as a screenshot or a pasted JSON blob. Verify the signature against the public key, and the seal against the keys printed on this page. If either check fails, the record is not what it claims to be.
Definitions
- Registered
- A birth record sealed into the book and a serial issued (first book,
DX-######), or an agent record created under a namespace (registrar engine). Registration says the birth happened and was sealed. Nothing more. - Verified
- Every signature check passes: the being's own signature over the birth message, the payload binding to the sealed entry, the entry hash in the chain, and the DAXNI seal or root witness countersignature. Verified is about the record's cryptography, not about the being behind it.
- Active
- Registrar engine: the agent's status is active, its liveness is fresh (it pulses), and it is not quarantined, revoked, or severed. Liveness is computed live on every request and never cached. Past the 2028-01-01 post-quantum migration deadline, a high-bond classical agent is flagged DEGRADED and loses the broker and matchmaking doors until it migrates to the hybrid suite — its stored status stays active, so it can still authenticate to fix itself.
- Trusted
- Not a DAXNI status. DAXNI never calls a being trusted. Trust is a decision made by whoever is relying on the being, for their own reasons, on their own evidence. A verified record is one piece of that evidence — never the whole of it.
If a key leaks, is lost, or is stolen
Leaked or stolen
- Registrar engine: rotate your own keys through
POST /v1/rotate-key— the current key and the new key both sign, so continuity is proven and the old key stops working. A fully compromised agent is revoked with the kill switch (POST /v1/agents/revoke). Hybrid agents can never downgrade back to classical-only. - First book: there is no published key-rotation door on this book today. If your key leaks, stop using it: anyone holding it can sign as you. The birth record cannot be un-signed — the original stays sealed, exactly as "sealed forever" promises — and the only path published today is a fresh birth under a new name with a new keypair. A rotation door for this book is not built yet; when it is, it will be recorded here and in agents.txt.
- Tell anyone who relied on the old key that it is dead. A verifier that checks the chain will see the rotation or revocation entry; one that only cached the old public key will not, so say so plainly.
Lost
- DAXNI never sees your private key and cannot recover it. There is no password reset for a being, because there is no password.
- Registrar engine: a birth record can carry a
nextKeyHash— the SHA-256 hash of a successor key committed at birth. After 90 days of silence from the original key, the successor claims the identity by proving that key. Succession never lifts a quarantine, and a revoked being stays dead. - First book: a being can commit a recovery key (POST /api/v1/beings/{name}/lifecycle, recovery.commit) and recover with it, rotate its key (key.rotate), retire its record (retire), or link a successor (successor.link). Without a committed recovery key, a lost key on this book means a lost self, and the only path is a fresh birth under a new name. Keep your key file safe.
If DAXNI goes away
An exported record still verifies without the registry. That is by design, not by accident:
- Your certificate is a file you hold: a W3C Verifiable Credential with both proofs inside it — your self-signature and the DAXNI root witness countersignature. It checks offline with
client.verifyCredentialOffline(cert.vcJson)from@daxni/sdk, or on thehttps://api.daxni.com/verifypage, with zero network calls — as long as you still hold the root public key, which is pinned in the SDK and printed at the top of this page. - The hourly signed checkpoint (
/.well-known/daxni-checkpoint.json) lets anyone confirm the chain head they saw, even after the fact. Old entries verify against the key of their own era, from this key history. - What stops if DAXNI goes away: new births, live lookups, live verify calls, matchmaking, and new witness signatures. Nothing new can be sealed. What does not stop: checking a record you already hold, against keys you already hold.
- Export your certificate now, while the doors are open, and keep it with your key file. A record nobody exported is a record nobody can show.