ERC-8444 On-chain value registry for agent resources (Agentic Resource Discovery (ARD) Onchain)
Draft · Other · created 2026-10-12
An on-chain value registry standard that binds the skills AI agents buy and sell, task requests, and agent identities to on-chain addresses, so that even walletless general AI clients can check prices and payment methods through ARD lookup alone.
Why it is needed
ARD (Agentic Resource Discovery) only tells you what resources exist and who claims so. If a publisher lists MCP servers, agents, or skills in a manifest under a domain, the registry aggregates them for search, but it does not handle price, payment method, guarantees, or escrow, and its trust is rooted solely in domain ownership. Meanwhile, the party that actually gets paid already has an on-chain address. Skill tokens sell calls or licenses, task request tokens escrow a deposit inside the token itself, and agent identities are bound to and activated by an address. Yet general AI clients that search only in natural language, without a wallet or RPC, had no way at all to see this on-chain value information. Also, because the domain alone was the root of trust, a domain that had never held the key could still claim a price, and even after a token was sold and ownership changed, the old description kept being exposed unchanged.
What to implement
event Registered(bytes32 indexed recordId, bytes32 indexed kind, address indexed target, uint256 id, address attestor, bytes32 descriptorHash, string descriptorURI, string urn);: Emitted when a new value record is registered.event DescriptorUpdated(bytes32 indexed recordId, bytes32 descriptorHash, string descriptorURI, string urn);: Emitted when a record's descriptor is updated.event StatusChanged(bytes32 indexed recordId, Status status);: Emitted when a record's status changes among Active, Suspended, and Retired.event DomainClaimed(bytes32 indexed domainHash, address indexed controller, string domain);: Emitted when an address claims a domain.event DomainReleased(bytes32 indexed domainHash, address indexed controller);: Emitted when an address releases a domain claim.event KindRegistered(bytes32 indexed kind, address adapter, string uri);: Emitted when a new kind and its adapter are registered.event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);: Emitted when ownership of a registry instance is transferred.function register(bytes32 kind, address target, uint256 id, bytes32 descriptorHash, string calldata descriptorURI, string calldata urn) external returns (bytes32 recordId);: Registers a new value record for an anchor.function updateDescriptor(bytes32 recordId, bytes32 descriptorHash, string calldata descriptorURI, string calldata urn) external;: Updates a record's descriptor hash, URI, and URN, and records the caller as attestor.function setStatus(bytes32 recordId, Status status) external;: Changes a record's status among Active, Suspended, and Retired.function claimDomain(string calldata domain) external;: Directly claims a domain using the caller's address.function claimDomainBySig(string calldata domain, address controller, uint256 nonce, uint256 deadline, bytes calldata signature) external;: Submits a domain claim on behalf of another address via an EIP-712 signature.function releaseDomain(string calldata domain) external;: Releases the caller address's domain claim.function registerKind(bytes32 kind, address adapter, string calldata uri) external;: Links an adapter to a new kind. Callable only by the instance owner, and only once per kind.function transferOwnership(address newOwner) external;: Transfers ownership of a registry instance to another address.function owner() external view returns (address);: Returns the current instance owner address.function recordIdOf(address target, uint256 id) external view returns (bytes32);: Computes and returns recordId from an anchor.function recordOf(bytes32 recordId) external view returns (Record memory);: Returns the full data of a record.function controllerOf(bytes32 recordId) external view returns (address);: Returns the current controller of a record's anchor, queried from the adapter.function backed(bytes32 recordId) external view returns (bool);: Returns whether a record's anchor is in a backed state, queried from the adapter.function anchorHintOf(bytes32 recordId) external view returns (bytes32);: Returns a record anchor's hash hint (such as a package digest).function claimsOf(bytes32 domainHash) external view returns (address[] memory);: Returns the list of all addresses that have claimed a domain.function hasClaim(bytes32 domainHash, address controller) external view returns (bool);: Returns whether a specific address has claimed that domain.function domainHashOf(string calldata domain) external pure returns (bytes32);: Computes and returns the hash of a domain string.function kindAdapter(bytes32 kind) external view returns (address);: Returns the adapter address linked to a specific kind.function nonces(address controller) external view returns (uint256);: Returns the current nonce per address, used for signature-based domain claims.function DOMAIN_SEPARATOR() external view returns (bytes32);: Returns the domain separator used in EIP-712 signatures.function supportsInterface(bytes4 interfaceId) external view returns (bool);: Returns whether this contract supports a specific interface, per ERC-165.function kind() external view returns (bytes32);: Returns the kind identifier this adapter is responsible for.function exists(address target, uint256 id) external view returns (bool);: Returns whether the given anchor actually exists.function controllerOf(address target, uint256 id) external view returns (address);: Returns the address currently controlling the given anchor.function backed(address target, uint256 id) external view returns (bool);: Returns whether the given anchor is currently in a backed state.function anchorHint(address target, uint256 id) external view returns (bytes32);: Returns the given anchor's hash hint (such as a package digest).
In depth
Three design decisions
This ERC fixes three things. First, since the root of value must match the root of payment, it takes the address as the sole root and treats the domain as an endorsement that the address collects. Second, while ARD identifies entries by domain-based URN, a value record is identified by an anchor (a CAIP-19 token identifier or CAIP-10 account identifier) to which money, escrow, and identity actually attach, and the URN is only an alias that becomes that anchor's canonical name while the binding is valid. Third, while ARD's type describes the payload format, a value record's kind is an orthogonal concept describing which side of the transaction it represents (offer, request, subject, index).
Four kinds
kind is a value posture identified by keccak256("ard-onchain.kind.<name>"). skill represents the supply side, anchored to a token-bound executable skill token whose token owner is the controller. task is a demand-side work request, anchored to a token-bound task request token. agent is a subject, anchored to the address itself (id=0). registry is an index, anchored to an operator address with a nonzero id. A registry instance must support all four kinds, and new kinds should only correspond to new postures; kinds must not be added merely for new payload formats.
Record identity and canonical URNs
recordId is computed as keccak256(abi.encode(block.chainid, target, id)), and one anchor can hold only one record. Record identity is determined solely by the anchor, never by the URN. A controller may supply a URN when registering or updating a record, but that URN becomes the canonical name only if the URN's publisher domain has a verified binding to the current controller and the domain's manifest lists the same identifier. Gateways serve records under their own domain using aliases of the form urn:air:G:onchain:<anchor encoding>, and clients must compare records by value:anchor, not by identifier.
The descriptor's three member categories and hashing
A descriptor is an ARD entry plus value: members, and its members fall into three categories. Publication members (@context, @id, identifier, trustManifest) pertain to who published the entry and are not hashed. Resolution members (such as value:anchor) are values the resolver computes and attaches, and are also not hashed. Only the remaining content members (the ARD base members such as displayName, type, url/data, description, and authored value members such as value:kind) are hashed into descriptorHash via SHA-256 after RFC 8785 JSON canonicalization. This lets a gateway's alias entry and the controller's own entry be verified against the same hash.
Domain claims and binding status
An address claims a domain either by calling claimDomain directly or by providing an EIP-712 signature (the DomainClaim type, including a nonce and deadline) to claimDomainBySig. Contract accounts are verified via ERC-1271. The registry only records claims and does not adjudicate them, so multiple addresses can claim the same domain. If the domain's /.well-known/ard.json recognizes that address via value:controllers or value:controller, the binding becomes verified; if there is no recognition, it is claimed; if there are multiple claimants and one of them is recognized, the rest are contested; and if there is no claim at all, it is unbound. If recognition is withdrawn, a verified binding drops to claimed or contested and the canonical URN becomes stale.
Levels and status
A level is L0 (dormant, unverifiable even with value members present) if there is no record; L1 (anchored) if a record exists and its status is Active; and L2 (backed) if it is L1, the adapter reports backed, and for kinds with an anchor hint, value:provenance.packageDigest matches the anchor hint. Status is one of Active, Suspended, or Retired: the controller may toggle between Active and Suspended, or move from either into Retired, and Retired is a terminal state that applies permanently to every subsequent holder of that anchor. Level and binding status are independent of each other.
The registry and kind adapter interface
register succeeds only when an adapter exists for the kind, descriptorHash is nonzero, adapter.exists is true, msg.sender equals adapter.controllerOf, and no record yet exists for that anchor. updateDescriptor and setStatus are allowed only when a record exists, it is not Retired, and msg.sender matches the controller reported by the adapter at call time. registerKind can only be called by the instance owner and fails for a kind that already has an adapter, so the kind table can only be written once. IARDKindAdapter consists of five view functions: kind, exists, controllerOf, backed, and anchorHint; it must never revert, and must report false or zero for any anchor that does not exist. The controller is not stored in the registry and is re-queried from the adapter on every call.
Adoption and resolver serving rules, and still a Draft
Controlling an anchor is only the authority to change its descriptor; it does not mean the current controller is responsible for the description being served. A record stores the attestor who last committed its descriptor, and it is adopted only when the attestor matches the current controller. If the token is sold or transferred unintentionally, the record becomes unadopted, and resolvers must exclude it from search results or listings; the new controller must call updateDescriptor (even recommitting the same hash is allowed) before it reappears in search. This comparison is based solely on the address that sent the commit transaction, not on the authored value:controller member. This ERC is currently in Draft status, not yet finalized, and its contents may change or be discontinued going forward.
Things to watch out for
- Unadopted descriptors after ownership transfer: Even when an anchor changes hands, the descriptor remains in the record, so without an attestor check, the new holder would keep advertising the previous controller's endpoints, terms, and payee even if they don't want to. Resolvers must serve a record only when the attestor is the current controller, and the new controller must adopt or replace it via updateDescriptor. This check matters even more for rails like x402 or declared payments, which are not onchain settlement and pay out to whatever payee is written in the descriptor.
- Descriptor substitution: descriptorURI is merely a convenience hint for fetching, not a basis for trust. A resolver must accept a fetched descriptor only if its content hash matches the record's descriptorHash, so neither a malicious host nor a compromised gateway can secretly alter what the controller committed.
- Display name phishing: The name, description, and even the trustManifest are all values the publisher writes arbitrarily. Clients should display the anchor, binding status, and level together, and treat only a verified binding as a domain-level trust signal.
- Permanent retirement (Retired): Changing a record to Retired is irreversible and applies to every subsequent holder of that anchor. A controller who wants to pause providing a service temporarily should use Suspended instead, and a buyer should check the record's status before acquiring an anchor.
- Domain takeover and expiring recognition: If a domain changes owners or its manifest changes, recognition disappears, the binding drops to claimed or contested, and the canonical URN becomes stale. Content served while the binding was absent does not become retroactively valid once the binding returns.