Abstract
This proposal defines the Generative Engine Optimization Framework (GEOF): a descriptive framework for recording how generative engines (answer engines, AI search surfaces, agent runtimes with discovery layers) represent an object, how that representation is measured, and how independent parties exchange and verify the resulting measurements.
GEOF defines eight content-addressed record types (Object, Frame, Source, Method, Intent, Metric Definition, Observation, Profile), a bounded observation container (Process) with versioned closure, a five-state value vocabulary, a metric identifier grammar, and a minimal on-chain registry that records declarations, observation commitments and attributable profile publications. The framework assigns no desirability to any value: it defines no thresholds, weights, ranking algorithms, engine policies or anti-abuse rules.
Motivation
Generative engines do not rank pages; they retrieve, select, synthesize and attribute. The measurements that grew up around classic search (impressions, clicks, position) describe only part of what happens, and the measurements that grew up around generative engines (mention rate, citation rate, share of voice, position-adjusted word count) are published by many tools under incompatible units and denominators. Two parties holding the same number cannot tell whether they measured the same thing.
Three further gaps motivate an on-chain framework rather than another metric list:
- Agentic discovery. When the recipient is an agent and the engine is an agent runtime with a discovery layer, "being cited" becomes "being invoked" and "being settled". These outcomes carry economic meaning and already leave on-chain traces (skill-token calls, task-tender settlements), but no shared vocabulary links them to the discovery event that caused them.
- Plural observers. The engine operator, the object holder and third-party panels each observe different parts of the same process. None of them can be the canonical source; the framework must let their statements coexist, each attributable and each bound to the frame, sources and methods it used.
- Intent-relative effect. The same dissemination can be a success under one intent and a failure under another. Statements about attainment or contribution are only meaningful relative to a declared intent, and must be separated from statements about what was observed.
GEOF supplies the common language in which these statements can be made, exchanged and checked. Prices, weights and settlement conditions are left to adopters.
Specification
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174.
1. Terms
- Subject / Object — the thing being represented: a content item, an entity, an offer, an agent, a skill, a task, a registry or a claim. An Object is engine-independent; its representation belongs to an Event.
- Engine — a system that retrieves, selects, synthesizes and attributes information in response to a trigger: an answer engine, an AI search surface, an agent runtime with a discovery layer.
- Trigger — the way an engine run started: an immediate query, a schedule, a subscription, a third party, or the engine itself.
- Recipient — a human or agent that receives a representation.
- Representation — what the engine did with an Object in one run.
- Reception — what a Recipient did after receiving a representation.
- Observer — an account that records Observations and may publish Profiles.
- Declarant — the account that submitted a declaration. A declaration confers no control over its subject.
- Opener — the account that opened a Process.
- Consumer — any party reading Profiles; Consumers decide which Observers, Sources and Methods they trust.
2. Record types
All records are JSON documents whose canonical form is the JSON Canonicalization Scheme (RFC 8785) and whose content hash is keccak256 of the canonical UTF-8 bytes. On-chain, a record is identified by its content hash; off-chain, by a URI that resolves to the document. JSON Schemas for every record type are provided as assets: shared definitions, Object, Frame, Source, Method, Intent, Metric Definition, Observation and Profile; a JSON-LD context maps the field names. Fields marked REQUIRED below MUST be present; schemas list every field.
2.1 Object
| Field | Req. | Meaning |
|---|---|---|
subjectId | REQUIRED | keccak256 of the canonical subject string <scheme>:<domain>:<identifier> (section 2.9) |
kind | REQUIRED | content, entity, offer, agent, skill, task, registry, claim, or an extension x:<publisher>/<name> |
identifiers | REQUIRED | one or more identifiers (URL, CAIP-10, CAIP-19, URN, DID, content hash) with their scheme |
relations | OPTIONAL | carrierOf, partOf, aliasOf, instanceOf, competesWith, x:... to other subjectIds |
externalRecords | OPTIONAL | references into other registries (for example an on-chain value registry record) by system label and reference |
holderClaims | OPTIONAL | claims of control over the Object, each with claimant, basis (registry-record, domain-acknowledgment, identity-binding, signature, declared) and evidence |
description | OPTIONAL | free text |
Any account MAY declare an Object for any subject. Several declarations for one subjectId MAY coexist. A declaration proves only that its declarant submitted that description; control over the Object requires an independent basis, which Consumers verify. An Object declaration MUST NOT be read as consent to, or veto over, observations or profiles about that Object.
2.2 Frame
A Frame bounds an observation. It has seven dimensions. Each dimension is a scope record:
{ "scope": "unrestricted" | "enumerated" | "not-applicable",
"values": [ ... ],
"coverageObserved": [ ... ] }unrestricted means the Observer imposed no restriction; it does not mean the Observer covered everything. enumerated lists the values the Observer intended to cover; coverageObserved lists the values actually covered. not-applicable means the dimension has no meaning for this Frame (for example queries for an unsolicited push).
| Dimension | Values |
|---|---|
time | window start and end, cadence |
engines | engine identifiers with version and surface |
queries | prompt-set reference (content hash), intent classes |
locales | region, language, modality, surface |
objects | subjectIds |
observers | observer accounts |
repetition | runs per cell, timing policy |
A Frame MUST also carry observationGranularity and disclosureGranularity, each one of individual, cohort, aggregate, commitment-only. The two MAY differ. A Frame MUST name its three clocks: eventEnd (when a run's representation is final), processClose (when the opener freezes an evidence version) and observationCutoff (after which receptions are no longer attributed to the frozen version).
2.3 Source
| Field | Req. | Meaning |
|---|---|---|
class | REQUIRED | engine-native, observer-sampled, publisher-side, recipient-side, third-party-corpus, onchain |
roles | REQUIRED | one or more of engine-input, observation, evaluation |
party | REQUIRED | first, second, third |
access | REQUIRED | how the material was obtained |
verifiability | REQUIRED | signed, replayable, aggregate-only, none |
coverage, latency, license, visibilityScope | OPTIONAL | as named |
The same material MAY be declared under several roles; each role is a separate declaration or a separate entry in roles. A Source with verifiability: aggregate-only supports aggregate Observations (section 2.7) and MUST NOT be used to fabricate instance-level Events.
2.4 Method
| Field | Req. | Meaning |
|---|---|---|
class | REQUIRED | sampling, detection, scoring, attribution, aggregation, verification, replay |
role | REQUIRED | engine, observer, evaluator |
parameters | REQUIRED | the parameters that fix this version |
inputs | REQUIRED | Source classes consumed |
outputs | REQUIRED | Metric Definition identifiers produced |
limitations | REQUIRED | known limitations, possibly empty |
supersedes | OPTIONAL | content hash of the previous version |
A Method is immutable once declared. Any change to parameters, inputs or outputs is a new Method with supersedes set.
2.5 Intent
An Intent is a dissemination intent: what a declarant wanted a dissemination to do. It is OPTIONAL for a Process.
| Field | Req. | Meaning |
|---|---|---|
declarant, declaredAt | REQUIRED | who declared it and when (clock value) |
mode | REQUIRED | ex-ante (declared before the window) or ex-post (reconstructed afterwards) |
basis | REQUIRED if ex-post | the materials the reconstruction rests on |
audience | REQUIRED | who the dissemination addressed: a scope record over recipient classes or enumerated recipients |
content | REQUIRED | the subjectIds the intent concerns |
expectedChange | REQUIRED | one or more of received, aware, understood, remembered, relayed, adopted, invoked, acted, ceased, maintained, x:... |
conditions, evaluationWindow | OPTIONAL | conditions and deadline for evaluation |
A Process MAY bind several Intents. An Intent never changes what was observed; it changes only which attainment and attribution statements can be made.
2.6 Metric Definition
A Metric Definition fixes what a reading means. It is identified by a metric identifier (section 2.10) and is immutable; a change to statistical unit, numerator, denominator, eligibility, de-duplication or aggregation is a new version.
| Field | Req. | Meaning |
|---|---|---|
id | REQUIRED | metric identifier |
family | REQUIRED | one of the ten families (section 3) |
basis | REQUIRED | outcome (derived from Observations) or condition (a state of the Object or its carrier) |
statUnit | REQUIRED | the thing counted: run, answer, object-in-answer, recipient, call, crawl, period, ... |
numerator, denominator | REQUIRED for ratios | what is counted above and below |
eligibility | REQUIRED | which units qualify for the denominator |
dedup | REQUIRED | de-duplication rule |
aggregation | REQUIRED | how instance values combine |
valueType | REQUIRED | count, ratio, share, score, duration, amount, state, distribution |
supersedes | OPTIONAL | previous version |
A Metric Definition MUST NOT carry a preferred direction. This specification assigns no desirability to any value.
2.7 Observation
An Observation records something that happened. Its kind is one of:
event— one run or delivery instance (section 2.7.1);aggregate— counts over a period from a Source whose granularity does not reach instances;followup— a Recipient action after a representation (section 2.7.2);intervention— an action by the object holder or another party on the Object or its carriers.
Every Observation carries observer, sourceRefs, recordedAt (clock value) and, where the Source reports its own time, reportedAt. Reported time and recorded time MUST stay distinct fields.
2.7.1 Event
An Event has three parts. Each field in course and conclusion takes a value or one of the states ABSENT, UNOBSERVED, NOT_APPLICABLE (section 2.11).
Origin (how the run started):
| Field | Meaning |
|---|---|
trigger.initiator | recipient, engine, schedule, third-party |
trigger.priorAuthorization | none, subscribed, delegated, unknown |
trigger.immediateQuery | whether an immediate query was present |
trigger.queryRef, trigger.queryIntent | the query (by hash or text) and its class: informational, navigational, transactional, agentic-task, unstated |
engine | identifier, version, surface |
recipientClass | human, agent, unknown |
delivery.channel | answer, notification, feed, tool-result, voice, other |
time, locale | clock value; region, language, modality |
Course (what the engine did internally), one state per stage: retrieved, selected, synthesized, attributed, delivered. A stage the Observer could not see is UNOBSERVED, never omitted.
Conclusion, one entry per Object touched:
| Field | Meaning |
|---|---|
objectRef | subjectId |
kind | OMITTED, RETRIEVED_NOT_USED, MENTIONED, CITED, RECOMMENDED, INVOKED |
actor | who performed the action named by kind: engine, recipient, unknown |
prominence | position, share of answer, first-citation flag, or a scoring Method reference |
stance | introduces, supports, questions, opposes, unstated |
claimCoverage | for claim Objects: which declared propositions were present |
fidelityFlags | misrepresented, stale, misattributed, each with the reference it was checked against |
reception | feedback, click, dwell and similar signals recorded within eventEnd; later actions are followup Observations |
One run MAY touch many Objects; each is a separate conclusion entry. An engine that cites one company's document and recommends its competitor produces two entries.
2.7.2 Follow-up
A followup Observation records a Recipient action: ADOPTED, INVOKED, ACTED, TRANSACTED, RELAYED, CEASED, MAINTAINED, FEEDBACK (with polarity), CLICKED, x:.... It carries linkBasis — deterministic, probabilistic, declared or unknown — and the Event references it is linked to. A follow-up with linkBasis: unknown is still a valid Observation; it supports no attribution statement.
2.8 Profile
A Profile is a set of statements published by one account against one Process version.
| Field | Req. | Meaning |
|---|---|---|
publisher | REQUIRED | the publishing account |
processRef, processVersion | REQUIRED | the Process and the frozen version read |
statements | REQUIRED | one or more statements (below) |
composites | OPTIONAL | composite scores, each listing component statementIds, weights and the Method that combines them |
supersedes | OPTIONAL | content hash of the Profile this one replaces |
visibilityScope, unverifiedPremises | REQUIRED | what the publisher could see; premises assumed but not checked (possibly empty) |
Each statement carries:
| Field | Req. | Meaning |
|---|---|---|
statementId | REQUIRED | unique within the Profile |
metricRef | REQUIRED | Metric Definition identifier |
objectRef | REQUIRED unless the metric is Process-level | subjectId |
value | REQUIRED | a value or one of the five states |
numeratorCount, denominatorCount | REQUIRED for ratios | the counts behind the value |
coverage | REQUIRED | units with records / units in the eligible population |
window, frameRef | REQUIRED | the time window and the Frame |
sourceRefs, methodRef | REQUIRED | Sources read and Method applied |
uncertainty | REQUIRED | an interval, a variance, or UNOBSERVED |
intentRef | REQUIRED for attainment and attribution families | the Intent evaluated |
referenceSet, comparator, proposition | REQUIRED for fidelity family | what was checked, against what, by which Method |
independenceBasis | REQUIRED for consensus metrics | how source independence was established |
rationale | REQUIRED | human-readable calculation rationale |
evidenceRefs | OPTIONAL | Observation references or Merkle proofs |
2.9 Subject encoding
The canonical subject string is <scheme>:<domain>:<identifier>: scheme lower-case ASCII letters; domain the lower-case authority (a DNS name, a CAIP chain id, or the literal - when none applies); identifier as issued by the authority. subjectId = keccak256(utf8(canonicalSubjectString)). Addresses are never left-padded into subjectId; an address-rooted subject uses the caip10 scheme. Commitments to hidden subjects are out of scope for the kernel and MAY be defined as a profile.
2.10 Metric identifier grammar
geof:<family>/<metric>/v<N>
geof:x/<publisher>/<metric>/v<N>family is one of the ten families in section 3. metric is lower-case ASCII with hyphens. N is a positive integer. publisher in the extension form is a stable namespace token: either the publisher's lower-case hex address or a DNS name the publisher controls; the binding between the token and the publishing account is declared off-chain and verified by Consumers. A metric identifier names a definition, never a reading; readings are statements.
2.11 Value states
Every observed field and every statement value is a value or exactly one of:
| State | Meaning |
|---|---|
ABSENT | checked, and explicitly none (the Object did not appear in a fully read answer) |
UNOBSERVED | the Observer had no material to check (no retrieval log, no recipient signal) |
NOT_APPLICABLE | the field has no meaning here (no query for an unsolicited push) |
UNDETERMINABLE | material was available but the declared Method could not reach a determination (integrity could not be confirmed, raters disagreed beyond the Method's tolerance) |
UNOBSERVED MUST NOT be reported as zero. The absence of a statement is not a statement.
3. Families
Statements belong to one of ten families. The families are a grammar, not a scorecard; the specification fixes no metric list beyond the identifiers in the informative vocabulary (metric vocabulary).
| Family | What it describes | Examples (informative) |
|---|---|---|
exposure | whether the Object entered candidate sets and reached recipients | retrieval-inclusion-rate, answer-inclusion-rate, invocation-incidence, invocation-intensity, crawl-rate, targeted-reach |
presentation | how the engine presented it | mention-rate, citation-rate, first-citation-share, prominence (position-adjusted), recommendation-rate, push-sent/delivered/displayed, share-of-voice, cross-engine-breadth, stance-distribution |
reception | what recipients did | positive-feedback-rate, negative-feedback-rate, no-feedback-rate, citation-click-rate, adoption-rate, execution-success-rate, reuse-rate, dispute-rate |
fidelity | truth relations, each against a declared reference set | occurrence-verified (did it happen), relay-fidelity (engine vs source), claim-support (source vs external reference), attribution-accuracy, consensus-degree with independence basis, omission-rate, staleness-lag |
seo | classic search measurements, kept in their source platform's units | impressions, clicks, ctr, average-position, indexed-pages, crawl-frequency, referring-domains; condition-type: core-web-vitals, structured-data-coverage, canonical-state |
access | conditions of access and governance | crawl-permission-state, licensing-terms-state, crawler-auth-state, content-credential-presence |
dynamics | change over repetition and time | run-to-run-volatility, persistence, freshness-lag, cross-model-consistency |
economics | ledger facts, no pricing rules | actual-spend, actual-revenue, allocated-amount (by a declared rule), estimated-incremental-value (by an attribution Method) |
attainment | how far a declared Intent's expected change occurred | attainment-rate per expectedChange, with coverage |
attribution | how much of an outcome is due to this dissemination | incremental-contribution with counterfactual Method, or declared basis |
Statements in attainment and attribution MUST carry intentRef. A Process without an Intent supports the first eight families only. attainment and attribution are always separate statements; a goal reached is not evidence of contribution.
4. Process
A Process is an observation container.
- An Opener opens a Process by binding one Frame, one or more Objects, zero or more Intents, and the Sources and Methods it announces. The Process starts at version 1 in state
Observing. - Any account MAY commit Observations to the current open version. Each commitment is attributable to its sender and carries a Merkle root, a count and the Observation kind.
- The Opener closes the current version, recording an evidence root and the
observationCutoff. The version is frozen: its commitments and evidence root never change. - The Opener MAY open an addendum, creating the next version for late Observations. Frozen versions remain readable.
- Any account MAY publish a Profile against any frozen version. Several Profiles per version by different publishers MAY coexist; a publisher replaces its own Profile by publishing a new one with
supersedesset. Nothing in the kernel designates an official Profile.
An Observer who wants its own closure discipline opens its own Process against the same Frame. Disputes about a Profile reference a statementId; the kernel records no disputes.
5. Registry interface
The registry MUST implement ERC-165 and ERC-6372. Every stored time is a value of the registry's own clock(); one deployment has exactly one clock domain. The full interface with NatSpec is provided as IGEOFRegistry.sol.
interface IGEOFRegistry {
enum DeclarationKind { OBJECT, FRAME, SOURCE, METHOD, INTENT, METRIC }
enum ObservationKind { EVENT, AGGREGATE, FOLLOWUP, INTERVENTION }
event Declared(bytes32 indexed id, DeclarationKind indexed kind, address indexed declarant,
bytes32 contentHash, bytes32 supersedes, string uri);
event SubjectBound(bytes32 indexed id, bytes32 indexed subjectId);
event ProcessOpened(bytes32 indexed processId, address indexed opener, bytes32 indexed frameId,
bytes32[] objectIds, bytes32[] intentIds, bytes32[] sourceIds, bytes32[] methodIds);
event ObservationsCommitted(bytes32 indexed processId, uint32 indexed version, address indexed observer,
bytes32 root, uint64 count, ObservationKind kind);
event ProcessClosed(bytes32 indexed processId, uint32 indexed version, bytes32 evidenceRoot, uint48 observationCutoff);
event AddendumOpened(bytes32 indexed processId, uint32 indexed version);
event ProfilePublished(bytes32 indexed profileId, bytes32 indexed processId, uint32 version,
address indexed publisher, bytes32 profileHash, bytes32 supersedes, string uri);
function declare(DeclarationKind kind, bytes32 contentHash, bytes32 supersedes, string calldata uri)
external returns (bytes32 id);
function declareObject(bytes32 subjectId, bytes32 contentHash, bytes32 supersedes, string calldata uri)
external returns (bytes32 id);
function openProcess(bytes32 frameId, bytes32[] calldata objectIds, bytes32[] calldata intentIds,
bytes32[] calldata sourceIds, bytes32[] calldata methodIds)
external returns (bytes32 processId);
function commitObservations(bytes32 processId, bytes32 root, uint64 count, ObservationKind kind) external;
function closeProcess(bytes32 processId, bytes32 evidenceRoot, uint48 observationCutoff) external;
function openAddendum(bytes32 processId) external returns (uint32 version);
function publishProfile(bytes32 processId, uint32 version, bytes32 profileHash, bytes32 supersedes,
string calldata uri) external returns (bytes32 profileId);
function declarationOf(bytes32 id) external view
returns (DeclarationKind kind, address declarant, bytes32 contentHash, bytes32 supersedes, uint48 declaredAt, string memory uri);
function subjectOf(bytes32 id) external view returns (bytes32 subjectId);
function processOf(bytes32 processId) external view
returns (address opener, bytes32 frameId, uint32 currentVersion, bool open);
function processBindings(bytes32 processId) external view
returns (bytes32[] memory objectIds, bytes32[] memory intentIds, bytes32[] memory sourceIds, bytes32[] memory methodIds);
function versionOf(bytes32 processId, uint32 version) external view
returns (bytes32 evidenceRoot, uint48 observationCutoff, uint64 commitmentCount, bool frozen);
function profileOf(bytes32 profileId) external view
returns (bytes32 processId, uint32 version, address publisher, bytes32 profileHash, bytes32 supersedes, uint48 publishedAt, string memory uri);
}Rules:
declareanddeclareObjectMUST be callable by any account. The id iskeccak256(abi.encode(kind, msg.sender, contentHash)); re-declaring an identical record by the same account MUST revert.declareObjectMUST additionally emitSubjectBound.supersedes, when non-zero, MUST name a declaration of the same kind by the same declarant.openProcessMUST verify that every referenced id exists and has the expected kind.processIdiskeccak256(abi.encode(msg.sender, frameId, nonce))wherenonceis a per-opener counter starting at zero, so process ids are predictable off-chain and independent of block time.commitObservationsMUST be callable by any account while the current version is open, and MUST revert when it is frozen.closeProcessandopenAddendumMUST be restricted to the Opener.closeProcessMUST revert if the current version is already frozen;openAddendumMUST revert if the current version is open.publishProfileMUST be callable by any account, MUST require the named version to be frozen, andsupersedes, when non-zero, MUST name a Profile by the same publisher on the same Process.- The registry MUST NOT interpret, validate or score the contents of any record. It stores hashes, URIs, attribution and ordering.
6. Off-chain conformance
A conforming off-chain implementation:
- validates records against the published schemas and the canonicalization rule;
- reconstructs a Process from events alone (declarations, commitments, closures, profiles);
- verifies that a Profile's
processVersionis frozen and that each statement'sframeRef,sourceRefsandmethodRefresolve to declarations bound to that Process; - rejects statements in the
attainmentorattributionfamilies withoutintentRef, andfidelitystatements withoutreferenceSet,comparatorandproposition; - renders every state in section 2.11 distinctly and never collapses
UNOBSERVEDinto zero.
Rationale
Declarations instead of mandates. Engines are black boxes that change weekly; measurement methods multiply. Fixing any method would date the framework within months. Fixing what must be declared does not.
No number without its frame. The same name ("citation share") is published with answers as the denominator by one tool and with all citations under a query as the denominator by another. Both are valid; neither is comparable to the other. Carrying numerator, denominator, eligibility and de-duplication on every ratio moves the disagreement from silent to visible.
Five states. "Did not appear in a fully read answer" (ABSENT), "we had no retrieval log" (UNOBSERVED), "there was no query to speak of" (NOT_APPLICABLE) and "raters could not decide" (UNDETERMINABLE) are four different facts that a single zero destroys.
Intent as an optional record. Most GEO tooling measures without any statement of what the dissemination was for; those measurements remain valid under GEOF. Only claims of effectiveness need an Intent, because effectiveness is relative to one. Keeping Intent optional keeps the base observation model intact; making intentRef REQUIRED for attainment and attribution keeps the effectiveness claims honest.
Attainment and attribution separate. Seventy of a hundred recipients completing a migration says nothing about how many would have completed it anyway. Adopters settle on delivery, on action, or on incremental action; the framework gives them three distinct statements to settle on.
Representation ends at INVOKED; TRANSACTED is a follow-up. An engine can mention, cite, recommend or call. A purchase, a settled task or a payment is something a recipient does afterwards, possibly days later, possibly after several contacts. Recording the run and the transaction separately, with a stated linkBasis, covers multi-touch, delayed and unattributable outcomes without pretending the engine transacted.
Object declarations confer no control. First-come registration of a brand or a public claim would create a squatting market and give one party veto power over observations about a shared subject. Declarations are attributable descriptions; control claims carry their basis and are verified by consumers.
Versioned closure instead of a single close. Receipts arrive late, a second observer publishes later, a third party disputes one fidelity statement. Freezing a version lets profiles bind to a fixed evidence set while addenda absorb what arrives afterwards.
Why on-chain at all. The kernel records only what independent parties need to exchange a measurement and check it: who declared what, when, against which frozen evidence, superseding what. External facts are supported by evidence; the chain supports attribution, ordering and immutability of the declarations.
Agentic GEO in scope. When discovery is performed by an agent runtime, invocation and settlement are the representation and reception events, and they already leave on-chain traces. Treating them as a second application of the same model, rather than a separate framework, is the reason the model distinguishes actor on INVOKED and keeps follow-ups linkable to on-chain records.
Relation to adjacent frameworks (informative). An information-flow paradigm registry describes how information moves between agents; GEOF describes what an engine did with an object and how that is measured. A GEO Process may span several information flows, and a monthly platform report can support a Profile without any single flow being visible, so GEOF references such frameworks by semantic mapping rather than dependency. Objects of kind skill, task, agent and registry are expected to reference records in an on-chain value registry through externalRecords; identity, credit, safety-adoption and dispute frameworks are expected to consume Profiles through their own interfaces.
Backwards Compatibility
GEOF introduces new interfaces and record types and modifies no existing standard. Classic search measurements are carried in the seo family in their source platform's units, so existing reporting migrates without re-definition. Research metrics such as position-adjusted word count and subjective impression are expressible as presentation Metric Definitions with a declared scoring Method.
Test Cases
Canonicalization is RFC 8785; hashes are keccak256 over UTF-8 bytes; abi.encode is the Solidity ABI encoding.
Subject identifiers (subjectId = keccak256(utf8(canonicalSubject))):
| canonicalSubject | subjectId |
|---|---|
claim:example.com:warranty-correction-2026-10 | 0x218830d41525a8cc55a22cc008a9af9b5b323861dcf5a9dba950d9e9290407be |
content:example.com:/notices/warranty-correction | 0x141a89f70943b33aae98e8c533f418b73c6ee87e7a28eee2f49e13d2b37d4e35 |
caip19:eip155:11155111:erc721:0x8338000000000000000000000000000000000001/42 | 0x61e9e8198037099f9e23259a635015d175ba0b0931bca3277f32e560f0b71339 |
Declaration id (keccak256(abi.encode(uint8 kind, address declarant, bytes32 contentHash))), with kind = 1 (FRAME), declarant = 0x2222222222222222222222222222222222222222 and contentHash = keccak256(utf8('{"a":1}')) = 0x25e7c2a96531eb50246780c1f25742e489bf55210e26981dc02992bb585feb97:
0x63e896c7b07a742ec2b46a06cf40acd1396b1e62c8bbcd46b17110bba182a195Profile id (keccak256(abi.encode(bytes32 processId, uint32 version, address publisher, bytes32 profileHash))), with processId = 0x7000000000000000000000000000000000000000000000000000000000000a01, version = 1, publisher = 0x2222222222222222222222222222222222222222 and profileHash = keccak256(utf8('{"b":2}')) = 0x39c6eef0731b991fda8c1165ce3ca386371f943806e05306e0394d74d165a623:
0xfe992dd35a73050fed34911d62ff377cb2ecf07b19ec216a6e834df7673b1211State machine, from a fresh process opened by account P:
commitObservationsby any account succeeds while version 1 is open;publishProfile(…, 1, …)reverts withGEOF_VersionOpen.closeProcessby an account other than P reverts withGEOF_NotOpener; by P it freezes version 1.- After the freeze,
commitObservationsreverts withGEOF_VersionFrozen;publishProfile(…, 1, …)by any account succeeds; a second call with the same(processId, version, publisher, profileHash)reverts withGEOF_DuplicateProfile. openAddendumby P opens version 2;commitObservationssucceeds again;versionOf(processId, 1)still returns the frozen root and count.publishProfile(…, 1, …, supersedes = X)reverts withGEOF_SupersedesMismatchunless X is a profile by the same publisher on the same process.
A fuller suite, including both worked cases walked end to end, accompanies the reference implementation.
Reference Implementation
A reference registry is provided as GEOFRegistry.sol against the interface IGEOFRegistry.sol. The two worked cases are provided as record bundles, case A and case B, with their derived hashes in vectors.json and an informative metric vocabulary. The registry will be deployed on a public test network with recorded evidence before this proposal leaves Draft.
Security Considerations
Squatting and impersonation of Objects. Any account may declare any subject. Consumers MUST treat holderClaims as claims and verify their basis; registries MAY offer a profile that requires a stake or an identity binding for declarations, outside the kernel.
Spam and noise. Processes, commitments and profiles are open. Consumers filter by Observer, Source and Method; indexers SHOULD expose attribution so filtering is cheap. The kernel's openness is deliberate (section 4); mitigation belongs in consumer policy.
Fabricated or selective evidence. Commitments bind an Observer to a Merkle root but prove nothing about the truth of the leaves. Replayable Sources, multiple independent Observers and the coverage field on every statement are the framework's defenses; Consumers SHOULD weight statements accordingly.
Panel manipulation. Observer-sampled Sources can be gamed by crafting prompt sets. Frames expose the prompt-set hash and repetition policy precisely so that this can be inspected; Observers MAY adopt published safety specifications covering panel construction.
Misreading states as zero. Implementations that collapse UNOBSERVED, NOT_APPLICABLE or UNDETERMINABLE into zero produce false absence. Section 6 makes distinct rendering a conformance requirement.
Recipient privacy. Individual recipients never appear in the public layer except through commitments; observationGranularity and disclosureGranularity are declared separately so a single authorized recipient's private receipt can support a statement without being disclosed.
Clock. All times are registry clock values; reportedAt from a Source is never written into recordedAt. A Source that reports times in another domain MUST declare the mapping in its record.
No enforcement. The kernel enforces nothing about engines, crawlers or licenses; access statements describe states and are not a licensing or consent mechanism.
Copyright
Copyright and related rights waived via CC0.
