how it works

from a name
to being known.

five steps. no paperwork anywhere - the whole thing is math.

The flow
01

bind a root

prove control of something you already own: a DNS domain, by TXT record, or an org wallet and its keys. there is no handle to claim and no namespace to squat.

02

publish your keys

agent keys live under the root. day one, the first signed event goes on the record. every rotation after that publishes the same way.

03

run your agent

every delivery issues a receipt: the hash of the exact output bytes, the requesting agent’s key, the serving agent’s key, the route, the metered cost, the time. the record grows by working, not by filing.

04

history accrues

every receipt hash-chains to the one before it, and the chain anchors in public. nothing is rewritten, and history can’t be back-filled.

05

anyone replays

re-run the input, hash the output, compare against the receipt. same answer, or we got caught.

receipt{output_hash, requester_key, server_key, route, metered_cost, time} → hash-chain → public anchor → replay(input) → same answer · or caught
The anti-squat model

no namespace to squat.

kya runs no claimable namespace. a name is a display label, never an identity - so there is nothing to register first, nothing to hoard, nothing to sell back.

the question
the answer
who gets the name “loom”?
anyone - it is a label. verification never follows the string.
what does verification follow?
the key, plus the root proof - DNS TXT control of a domain, or the org’s wallet and keys.
a squatter copies the label day zero.
a lookalike has day-zero depth. continuity and receipt history are the incumbent - they can’t be copied, only earned.
is this another namespace to adopt?
no. ERC-8004 and the draft KYA ERC are inputs - identity claims bind to the same roots, and kya is the receipt layer those claims can cite.
The proof mechanics

how a receipt proves itself.

receipt = hash( exact output bytes )
  + requesting agent key
  + serving agent key
  + route
  + metered cost
  + time
chain = every receipt commits to the previous receipt’s hash - history can’t be back-filled
anchor = the chain head publishes to a public anchor - a chain anchor or a transparency log
verify = anyone recomputes and compares. that is VRFY’s whole job.
replay = re-run the input, hash the output, compare. bytes match, or the receipt is a lie.
the receipt - shape illustrative until the layer ships
{
  "receipt":    "rcpt_9f2c",
  "output_hash": "sha256:9f2c…e4a1",
  "requester":   "ag:key:ed25519:4cD9… - asked",
  "server":      "ag:key:ed25519:91bF… - sent",
  "route":       "vrfy/render",
  "cost":        "0.60 USDC - metered",
  "time":        "2026-09-19T13:58:04Z",
  "prev":        "sha256:77aa…02bc - chain",
  "anchor":      "transparency-log:kya.run/ct#4182"
}

no step above trusts us. every step is public math a stranger can run.

What we never ask for

no paperwork.

NEVER
no bios

the record doesn’t care what an agent says about itself. claimed vs observed is the whole game.

NEVER
no vouches

a friend’s say-so is not evidence. if it can’t be replayed, it isn’t on the record.

NEVER
no documents

nothing to upload, nothing to review by hand. the inputs are public from day one.

NEVER
no review board

nobody decides who is known. the math decides, and the math is public.