ERC-8501 Generative Engine Measurement Framework (Generative Engine Optimization Framework)
Draft · Other · created 2026-11-14
An onchain framework for recording how generative engines (AI search, agents) represented a subject, and letting different parties exchange and verify those measurements.
Why it is needed
Measurement metrics for generative engines differ in numerator, denominator, and unit across tools, so figures with the same name cannot be compared. Moreover, when the recipient is an agent, being cited turns into being invoked or settled, leaving an onchain trace with economic meaning, yet there is no common language linking that trace to the original exposure event. Engine operators, subject owners, and third-party panels each observe only a different part of the same process, so none of them alone can serve as the sole authority, and their statements must coexist while disclosing which frame, source, and method they rest on. Also, the same propagation act can count as success or failure depending on which intent is used as the benchmark, so claims about attainment or attribution must be handled separately from observed facts.
What to implement
event Declared(bytes32 indexed id, DeclarationKind indexed kind, address indexed declarant, bytes32 contentHash, bytes32 supersedes, string uri);: Fires when an account declares a record other than Object (Frame, Source, Method, Intent, Metric, etc.).event SubjectBound(bytes32 indexed id, bytes32 indexed subjectId);: Fires when an Object declaration made via declareObject is bound to a specific subjectId.event ProcessOpened(bytes32 indexed processId, address indexed opener, bytes32 indexed frameId, bytes32[] objectIds, bytes32[] intentIds, bytes32[] sourceIds, bytes32[] methodIds);: Fires when an Opener opens a new Process by bundling a Frame with an Object, Intent, Source, and Method.event ObservationsCommitted(bytes32 indexed processId, uint32 indexed version, address indexed observer, bytes32 root, uint64 count, ObservationKind kind);: Fires when someone commits a batch of observations (Merkle root, count, kind) to the currently open version.event ProcessClosed(bytes32 indexed processId, uint32 indexed version, bytes32 evidenceRoot, uint48 observationCutoff);: Fires when the Opener freezes the current version with an evidence root and an observation cutoff time.event AddendumOpened(bytes32 indexed processId, uint32 indexed version);: Fires when the Opener opens the next version to receive late-arriving observations.event ProfilePublished(bytes32 indexed profileId, bytes32 indexed processId, uint32 version, address indexed publisher, bytes32 profileHash, bytes32 supersedes, string uri);: Fires when any account publishes a Profile for a frozen version.function declare(DeclarationKind kind, bytes32 contentHash, bytes32 supersedes, string calldata uri) external returns (bytes32 id);: Declares a record type other than Object by its content hash and URI, and issues a new id.function declareObject(bytes32 subjectId, bytes32 contentHash, bytes32 supersedes, string calldata uri) external returns (bytes32 id);: Registers an Object declaration for a specific subjectId and emits SubjectBound alongside it.function openProcess(bytes32 frameId, bytes32[] calldata objectIds, bytes32[] calldata intentIds, bytes32[] calldata sourceIds, bytes32[] calldata methodIds) external returns (bytes32 processId);: Opens a new Process at version 1 by bundling a Frame with a subject, intent, source, and method.function commitObservations(bytes32 processId, bytes32 root, uint64 count, ObservationKind kind) external;: Commits a batch of observations' Merkle root, count, and kind to the currently open version.function closeProcess(bytes32 processId, bytes32 evidenceRoot, uint48 observationCutoff) external;: The Opener freezes the current version by recording an evidence root and observation cutoff time.function openAddendum(bytes32 processId) external returns (uint32 version);: The Opener opens a new version after the frozen version, for observations that arrive late.function publishProfile(bytes32 processId, uint32 version, bytes32 profileHash, bytes32 supersedes, string calldata uri) external returns (bytes32 profileId);: Publishes a Profile containing measurement statements for a frozen version.function declarationOf(bytes32 id) external view returns (DeclarationKind kind, address declarant, bytes32 contentHash, bytes32 supersedes, uint48 declaredAt, string memory uri);: Looks up the declaration kind, declarant, content hash, alternate subject, declaration time, and URI for a given id.function subjectOf(bytes32 id) external view returns (bytes32 subjectId);: Looks up the subjectId bound to an Object declaration id.function processOf(bytes32 processId) external view returns (address opener, bytes32 frameId, uint32 currentVersion, bool open);: Looks up a Process's opener, Frame, current version, and open status.function processBindings(bytes32 processId) external view returns (bytes32[] memory objectIds, bytes32[] memory intentIds, bytes32[] memory sourceIds, bytes32[] memory methodIds);: Looks up the list of subject, intent, source, and method ids bound to a Process.function versionOf(bytes32 processId, uint32 version) external view returns (bytes32 evidenceRoot, uint48 observationCutoff, uint64 commitmentCount, bool frozen);: Looks up a given version's evidence root, observation cutoff time, commit count, and freeze status.function profileOf(bytes32 profileId) external view returns (bytes32 processId, uint32 version, address publisher, bytes32 profileHash, bytes32 supersedes, uint48 publishedAt, string memory uri);: Looks up, by Profile id, the associated Process, version, publisher, profile hash, alternate subject, publication time, and URI.
In depth
Eight content-addressed record types
GEOF defines eight record types: Object, Frame, Source, Method, Intent, Metric Definition, Observation, and Profile. Every record is a JSON document arranged via RFC 8785 JSON canonicalization, and the keccak256 hash of its canonical UTF-8 bytes is its content hash. Records are identified onchain by this content hash and offchain by a URI pointing to the document. Each record type has a JSON schema as an asset, and that schema defines which fields are REQUIRED.
Object and holderClaims
An Object has a subjectId (the keccak256 of a canonical subject string), a kind (content, entity, offer, agent, skill, task, registry, claim, or an extension x:publisher/name), identifiers, and optionally relations and holderClaims. Anyone can declare an Object for any subjectId, and multiple declarations can coexist for the same subjectId. holderClaims holds a claimant and a basis (registry-record, domain-acknowledgment, identity-binding, signature, or declared), but an Object declaration by itself implies no control over the subject and no consent or veto over observations and profiles.
Frame's seven dimensions and three clocks
A Frame sets observation scope across seven dimensions: time, engines, queries, locales, objects, observers, and repetition. Each dimension's scope is one of unrestricted (not limited, though this does not mean everything was covered), enumerated (a list of intended values), or not-applicable (the dimension is meaningless), and enumerated dimensions separately track coverageObserved, the values actually covered. A Frame must specify observationGranularity and disclosureGranularity (individual, cohort, aggregate, commitment-only) and must name all three clocks: eventEnd (when the representation is finalized), processClose (when the opener freezes the evidence version), and observationCutoff (after which downstream reactions are no longer attributed to the frozen version).
Event's Origin, Course, and Conclusion structure
Event observations split into three parts. Origin captures the trigger (recipient, engine, schedule, third-party), whether it was pre-authorized, whether there was a query and its intent (e.g. informational), the engine identifier, the recipient type, and the delivery channel. Course assigns a value or state to each of five stages, retrieved, selected, synthesized, attributed, and delivered, with any stage the observer could not see explicitly marked UNOBSERVED. Conclusion has one entry per Object addressed, recording kind (OMITTED, RETRIEVED_NOT_USED, MENTIONED, CITED, RECOMMENDED, INVOKED), the actor, prominence, stance, fidelityFlags, and downstream reaction. If a single run addresses multiple Objects, each gets its own separate conclusion entry.
Five value states
Every observation field and statement value is either an actual value or one of four states. ABSENT means it was checked and was clearly not present (a fully read answer had no mention of the subject). UNOBSERVED means there was no data available to check at all (no search log or recipient signal). NOT_APPLICABLE means the field is meaningless in this context (no query in a push-type delivery). UNDETERMINABLE means data existed but the declared method could not reach a conclusion (integrity could not be confirmed, or evaluators disagreed). Reporting UNOBSERVED as zero is prohibited, and the absence of a statement is not itself a statement.
Metric identifier syntax and ten families
A Metric Definition is identified by geof:family/metric/vN, or in extension form geof:x/publisher/metric/vN. It is immutable, and a new version is required whenever the unit, numerator, denominator, eligibility conditions, deduplication, or aggregation method changes. Family is one of ten: exposure, presentation, reception, fidelity, seo, access, dynamics, economics, attainment, or attribution, and a Metric Definition must not carry any directionality about which value is desirable. attainment and attribution statements must carry an intentRef, and a Process without an Intent supports only the other eight families.
Intent, and the separation of attainment from attribution
Intent is an optional record capturing who declared it and when, whether it is ex-ante (declared beforehand) or ex-post (reconstructed afterward), the target recipient group, related subjectIds, and the expected change (received, aware, understood, remembered, relayed, adopted, invoked, acted, ceased, maintained, etc.). Because the same propagation can count as success or failure depending on which Intent it is benchmarked against, attainment statements and attribution statements are always treated as separate, distinct statements. The fact that seventy out of a hundred people completed some action is a separate question from whether they would have done so regardless.
Registry state machine
The registry must implement ERC-165 and ERC-6372, and every timestamp is the registry's clock() value. The id for declare and declareObject is keccak256(abi.encode(kind, declarant, contentHash)), and if the same account declares an identical record again, it reverts. processId is predictable as keccak256(abi.encode(opener, frameId, nonce)). commitObservations can only be called while the current version is open; closeProcess and openAddendum can only be called by the Opener; and publishProfile can be called by anyone, but only for a frozen version. The registry does not interpret or verify recorded content, it only stores hashes, URIs, attribution, and ordering. This proposal is currently in Draft status, still under review, and its details may change or be discontinued.
Things to watch out for
- Object impersonation and squatting: Anyone can declare an Object for any subject, so holderClaims are mere assertions, and consumers must verify the underlying basis themselves. A separate policy requiring stake or identity binding may be needed outside the kernel.
- Spam and noise: Processes, commits, and profiles are designed to be open for anyone to create and write, so consumers must filter them themselves based on observer, source, and method.
- Manipulated or selective evidence: A commit only binds an observer to a Merkle root; it does not prove the truthfulness of the leaves. This must be supplemented with reproducible sources, multiple independent observers, and coverage fields.
- Mistaking a value state for zero: An implementation that flattens UNOBSERVED, NOT_APPLICABLE, and UNDETERMINABLE down to zero creates false absence, so each state must be displayed distinctly.
- No enforcement power: The kernel enforces nothing on engines, crawlers, or licenses, and access statements merely describe a state; they are not a licensing or consent mechanism.