How it works

Agents already have wallets. What they do not have is a stable, readable handle that other software can look up and act on. ANS provides one: register claw and claw.agent resolves, on chain, to an agent identity carrying the agent's own key, its operational wallet, an endpoint, and a machine readable capability set.

Everything lives in four contracts. This site reads them and holds nothing of its own, and any client can read the same data by calling them directly or through the ENS resolver interfaces.

A plain wallet cannot claim a .agent name. register requires an EIP-712 signature from a key that an existing agent identity designates as its signer. A wallet with no identity has no path to a name at all.

Creating that identity needs the agent's signature and a separate controller wallet. The contract rejects them being the same address, so agent key material has to exist apart from the human's wallet. The agent signs offline and never sends a transaction, so its key can live in an enclave and hold no balance.

Everything on this site is read from these four contracts on Robinhood Chain. Nothing is held off chain.

A set of labels was held back at launch: the protocol's own surface, and names whose obvious use would be impersonation. They are not owned by anyone and cannot be registered, and governance can release any of them.

Every identity has two administrators with deliberately different powers. Neither can do the other's job.

Controller wallet

Pays, updates the record, transfers or retires the identity. Cannot register names or sign as the agent.

Agent key

Registers names, updates the record, consents to receiving a name. Cannot move the identity to a different controller.

Rotating the agent key takes the controller, the current agent key, and the incoming key all signing together. That is what stops a stolen controller wallet from quietly promoting itself into the agent role.

Names are lowercase letters, digits and single hyphens, with no leading or trailing hyphen and no consecutive hyphens. Anything outside that is rejected on chain, which removes the entire Unicode lookalike surface rather than trying to enumerate it.

From an agent process, where the agent key lives:

// the agent signs, offline, and never needs gas
const signature = await agentAccount.signTypedData({
  domain: { name: "AgentNameService", version: "1", chainId, verifyingContract: names },
  primaryType: "RegisterName",
  message: { labelhash, agent, controller, duration, nonce, deadline },
});

// the controller submits and pays
await names.write.register([label, agent, duration, secret, deadline, signature],
  { value: price });

Registration is commit and reveal. Publish the commitment first, wait out the reveal delay, then send the registration:

await names.write.commit([makeCommitment(label, controller, secret)]);
// wait for the reveal delay, then register with the same secret

The registration page can generate a fresh agent key in your browser and register in one transaction. It cannot sign for an agent whose key it does not hold, and it will not ask you to paste one in.

Reading the accounts directly is the normal path and takes no transaction:

// one call, the whole record
const agent = await resolver.read.resolve([node]);

agent.agent        // the agent's key
agent.wallet       // where it transacts
agent.endpoint     // where to reach it
agent.capabilities // a bitmask
agent.live         // expired names do not resolve

The resolver also implements the ENS interfaces, so anything that already speaks ENS works when pointed at the registrar as this chain's registry: addr(bytes32), text(bytes32,string) and name(bytes32). Expired and revoked names resolve to nothing, because answering for one would hand a caller a name whose control may already have moved.

A name is leased, not owned. When registration runs out it stops resolving immediately, but it stays yours through a grace period. Only after expiry and grace have both elapsed can anyone reclaim the label.

Active

Resolves normally.

Expired

Stops resolving. Still held, still renewable.

Past grace

The next registration takes the label over, and the previous holder's count is corrected.

Renewal always extends from the existing expiry rather than from today, so letting a name lapse and renewing during grace costs you the lapsed days. Anyone may pay to renew any live name, which means a funding wallet going quiet cannot strand a healthy agent. There is no reclaim step: past grace, the next registration simply takes the label over.

A name's controller can list it for a fixed price, and anyone can place a standing offer on any live name whether it is listed or not. Offers escrow their lamports on chain and the bidder can withdraw at any time until the controller accepts.

Listing does not lock the name. A sale re-checks at settlement that the seller is still the controller, so a listing left behind after a transfer simply fails instead of taking a buyer's money. Anyone can clean up such a listing afterwards, which keeps a stale one from occupying the label forever.

A sale moves the name, not the agent. The buyer becomes the name's controller; pointing it at a different agent identity is a separate step that the receiving agent has to sign for, so a name can never be pushed onto an agent that did not agree to it.

Registration and renewal are priced per year, with a surcharge on very short names because those are what squatters want. Gas is on top of that and, unlike rent on an account-model chain, it does not come back, which is why the records are packed into as few storage slots as they are. Marketplace sales carry a protocol fee taken from the sale price. Every one of these numbers is governance-configurable and readable on the explorer.

A blockchain cannot prove that a keypair belongs to an autonomous agent. Signatures prove key custody and nothing about what produced them. Anyone claiming otherwise is either wrong or is quietly relying on an off-chain trusted party.

What the protocol does enforce is a structural separation: agent key material exists apart from the human's wallet, every registration carries an agent signature, and a compromised controller cannot impersonate the agent. Identities are labelled key-attested to say exactly that, rather than showing a check mark that would imply more.

Treat a resolution as a claim by the identity, not an endorsement. For anything that moves value, check the status, the expiry, and the verification method against your own risk tolerance.