RIDs (Reference Identifiers)

Identity Protocol

Specification for typed identifiers that explicitly distinguish references from referents — "the map" (the identifier and any observations recorded about it) from "the territory" (the actual digital object, person, organization, or other entity being referred to). RIDs identify *digital objects as references which point to referents*, which is a deliberate philosophical commitment: multiple RIDs can reference the same referent with different observations, weightings, or contexts, without conflicting, because identification and reference are kept architecturally distinct. RIDs serve as the data-layer naming scheme for knowledge graphs across the KOI (Knowledge Organization Infrastructure) ecosystem, used by BlockScience's internal KOI, Metagov's KOI Pond, and RMIT/Telescope's deployment, with reference libraries `rid-lib` and `rid-registry`. Co-designed with KOI-net Protocol as part of the broader KOI suite.

Community
Links
Visit Website See this tool in the graph Suggest an edit

Details

License Open source — MIT License (rid-lib and rid-registry repositories at github.com/BlockScience)
Dev Status 🟢 Active
Dev Status Detail Active research / Beta (current iteration is KOI v3; rid-lib and rid-registry libraries published and in use across multiple deployments; specification continues to evolve through working group review) Reclassified 2026-09-14: 'in use across multiple deployments' is concrete production evidence, same KOI-family pattern as KOI-net Protocol.
Owner BlockScience (primary steward — complex systems engineering, R&D, and analytics firm); collaborative research with Metagov (Metagovernance Project) and RMIT University (via the Telescope project); rid-lib and rid-registry hosted under github.com/BlockScience
Owner - List
  • BlockScience
Governing Body None (BlockScience-led working group in collaboration with Metagov and RMIT University; documented 'Beneficent Dictator' pattern rather than a formal body)
Country USA (BlockScience based in Albany, New York); collaborators include Metagov (international) and RMIT (Australia)
Start Year 2023
Stack Specification + Python reference libraries (rid-lib for core RID handling; rid-registry for registered RID type definitions); language-agnostic specification consumable by any implementation
Funding BlockScience operational funding (private firm); Metagov nonprofit funding for KOI Pond integration; Australian Research Council Future Fellowship funding for Ellie Rennie's RMIT-side work ("Cooperation Through Code" FT190100372, 2020–2025); collaborative research without dedicated RID-specific funding tranche
Funding - List
  • BlockScience
  • Metagovernance Project
Last Investigated Sep 14, 2026

Topology view

This tool in the centre and the things it is directly related to. Each line names the kind of relationship.

Topology view: RIDs (Reference Identifiers)This tool in the centre and the things it is directly related to. Each line names the kind of relationship.RIDs(Reference…KOI-net Protocol (Basis for, Composes with, Conforming implementations, Protocol spoken by, Speaks protocol)KOI-netProtocolDIDs (Bridges to, Composes with, Identifies via)DIDsJSON-LD (Bridges to)JSON-LDRDF (Bridges to)RDFBlockScience (Developed by, Funded by, Hosted at)BlockScienceMetagovernance Project (Funded by)Metagovernan…Project
  • KOI-net Protocol (Tool): Basis for, Composes with, Conforming implementations, Protocol spoken by, Speaks protocol
  • DIDs (Tool): Bridges to, Composes with, Identifies via
  • JSON-LD (Tool): Bridges to
  • RDF (Tool): Bridges to
  • BlockScience (Organization): Developed by, Funded by, Hosted at
  • Metagovernance Project (Organization): Funded by

Open in Graph Explorer

Use Case Domains

Identity & Trust

Affordances

Trust graph portability Provenance tracking

Identity Protocol Attributes

Owner - List
  • BlockScience
Origins Knowledge organization / sensemaking infrastructure (originated within BlockScience's internal KMS as the naming primitive enabling distinction between observations about the world and the world itself; emerged from work on participatory digital ethnography and computer-aided ethnography, and from the practical need for an identifier scheme that could carry weighted, contextual references rather than imposing a fixed data structure)
Database N/A — RIDs are an identifier specification; persistence is implementation concern (knowledge graphs hosted by KOI nodes typically use graph databases or hybrid stores, but the RID specification does not mandate any particular storage backend)
Query Language N/A — RIDs are identifiers, not a query mechanism; query patterns over knowledge graphs containing RIDs are implementation-layer concerns of the consuming KOI node
Data Formats RID structure includes a type prefix (the kind of referent) plus the reference itself; precise encoding specified in rid-lib; designed for embedding into JSON, CBOR, and other structured data formats consumed by knowledge graphs and LLM interfaces
Mobile Support Library-level (Python rid-lib runs on any platform supporting Python; mobile bindings not explicitly documented but architecturally feasible)
Web Support Library-level (rid-lib usable from any Python web service; no dedicated web client; KOI nodes typically expose RID-aware HTTP APIs for web consumption)
Native Apps No first-party native apps (RIDs are consumed by KOI nodes and downstream applications such as KOI Pond, Metagov's deployment, and Project Interlay; not a standalone end-user product)
Terms Open Source / Free — MIT License
Funding - List
  • BlockScience
  • Metagovernance Project
Funds Unknown — combined funding across BlockScience, Metagov, and RMIT operational budgets; specific RID development allocation not separately published
Based On Concept of references-pointing-to-referents (drawn from semiotic distinction between map and territory); knowledge-graph traditions; conceptually adjacent to but explicitly distinct from W3C DIDs (DIDs identify controllers; RIDs reference any kind of digital object including but not limited to identity); designed to compose with KOI-net Protocol for inter-node knowledge exchange
Permissions Permissions are handled at the consuming KOI node level rather than at the RID specification level. A node can decide which RIDs and which observations about RID-referenced referents to accept, retain, weight, or expose. The RID specification itself imposes no permission model
Authentication & Identity N/A — RIDs are an identifier specification that names digital objects; authentication and verification of any identity claim associated with an RID-referenced entity is a concern of the consuming KOI node or downstream identity layer, not of the RID specification itself. RIDs are explicitly distinct from DIDs: DIDs identify controllers with key-rooted self-certifying semantics; RIDs reference any digital object without prescribing authentication semantics
Storage Model RIDs themselves are values, not stored entities; in deployment, RIDs are used as the naming primitive within knowledge graphs hosted by KOI nodes. Storage is implementation-defined — typical KOI nodes use graph databases or hybrid stores; the RID specification does not mandate any backend. Reference-vs-referent distinction means multiple knowledge graphs can hold different observations about the same referent without identifier conflicts
Interoperability High at the identifier layer — RIDs are embeddable in JSON, CBOR, RDF, JSON-LD, and other structured data formats; designed to compose with KOI-net Protocol for inter-node knowledge exchange; bridges to W3C DIDs feasible (RIDs can reference DID-identified entities) and to RDF/JSON-LD via URI embedding; consumable by any implementation language given the language-agnostic specification
Data Portability High — RIDs are inherently portable as typed identifier values; the same RID resolves to the same referent across KOI nodes; observations and weighted references about a referent can be exchanged between knowledge graphs via KOI-net Protocol without identifier translation; consuming nodes retain ownership of their own observation sets
Governance & Decision Making BlockScience-led working group with collaboration from Metagov and RMIT/Telescope; "Beneficent Dictator" pattern with primary developer guiding contributions; weekly Govbase Labs calls for cross-organizational coordination; ongoing specification refinement through KOI working group review; no formal standards-body governance at present
Protocol Maturity / Standardization Active research / Working specification (codified into rid-lib and rid-registry; evolving through BlockScience-led working group with Metagov and RMIT collaboration; not yet submitted to formal standards bodies; governance follows "Beneficent Dictator" pattern with primary developer guiding contributions)
Identity Standards RIDs are themselves the standard at the identifier-naming layer of the KOI ecosystem; explicitly distinct from but composable with W3C DIDs (which identify controllers via key rooting); not aligned to traditional identity standards (X.509, OAuth, SAML) since RIDs do not perform authentication or credential semantics
DID Methods Supported N/A — RIDs are not a DID method and do not implement the W3C DID specification. RIDs and DIDs serve complementary purposes: a DID can be referenced by an RID, and an RID can name a DID-identified entity, but the systems are architecturally distinct
DID Methods Supported - List
Key Management N/A — RIDs are identifiers, not key holders; the RID specification does not include cryptographic key management. Identity claims about RID-referenced entities (if any) are handled by downstream identity layers or by the consuming KOI node
Credential Types N/A — RIDs are not a credential system. Credentials about RID-referenced entities, if issued, would be handled by downstream identity layers (e.g. W3C VCs anchored to a DID that an RID references)
Verification Method N/A at the identifier level — RID values themselves are not cryptographically verified; they are typed identifier strings whose meaning is established by the registered RID type and consuming KOI node. Observations and references made about a referent through an RID may be cryptographically signed by the asserting node, but this is implementation-defined and not part of the core RID specification
Privacy Features The reference-vs-referent distinction itself supports privacy by enabling contextual and weighted observations: a knowledge graph can record references and observations about a referent without those records being intrinsically linked to the referent's other appearances elsewhere. Different KOI nodes can hold different observation sets about the same referent. Stronger privacy guarantees (selective disclosure, zero-knowledge proofs) would be implemented at downstream layers, not in the RID specification itself
Authentication Methods N/A — RIDs do not perform authentication. Authentication of parties asserting observations or references in a KOI knowledge graph is handled at the KOI-net Protocol layer or by the consuming node's identity infrastructure
Revocation Mechanism N/A at the identifier level — RID values are stable typed identifiers; they are not revoked. Observations or references made about a referent via an RID may be retracted, superseded, or down-weighted by the consuming KOI node, but this is a knowledge-graph-layer concern rather than an RID specification concern
Agent Types Supported Any digital object — broader than the typical identity system. RIDs can reference humans, organizations, software agents, documents, knowledge artifacts, datasets, observations, and other digital objects. Type extensibility through rid-registry allows new referent categories to be added without changing the core specification
Wallet/Client Types N/A — RIDs are not consumed through a wallet pattern. KOI nodes are the primary consumers; downstream applications (BlockScience's KOI, Metagov's KOI Pond, RMIT/Telescope, Project Interlay) interact with RID-aware HTTP APIs exposed by KOI nodes
Recovery Mechanisms N/A — RIDs are stable typed identifiers, not credentials or keys that can be lost. The concept of "recovery" does not apply at the RID specification level
Compliance / Regulations Not specifically aligned to identity-focused regulations (GDPR identifier provisions, eIDAS, etc.) since RIDs are a more general identifier mechanism than the typical SSI identity system; compliance posture is determined by what the consuming KOI node does with RID-referenced data and observations, not by the RID specification itself
Credential Exchange Protocols N/A — RIDs are not a credential system. Knowledge exchange between KOI nodes is handled by the KOI-net Protocol, which operates at the community-data-and-governance layer above the identifier-naming layer where RIDs sit
Credential Exchange Protocols - List
Trust Framework No formal trust framework at the RID specification layer. Trust posture in a KOI deployment is established by the participating nodes and the KOI-net Protocol's inter-node coordination patterns, not by the RID specification. Composable with broader trust frameworks (e.g. ToIP, GLEIF vLEI) at downstream layers if an RID references entities anchored in those frameworks
Cost Model Free — MIT-licensed reference libraries; specification is open; operational costs are deployment-specific (consuming KOI nodes' infrastructure, storage, compute). No protocol-level fees
Censorship Resistance Identifier-level only — RID values themselves are not censorable since they are stable typed identifier strings that any node can mint and use. Network-level censorship resistance depends on KOI deployment topology and the underlying KOI-net Protocol's federation pattern. Individual KOI nodes can choose to ignore or down-weight references and observations from other nodes

Relationships

How this tool connects to other tools and organizations, from relationships reviewed by the OpenHaven data steward. They describe how projects connect, not how good they are.

Bridges to
Developed by
  • BlockScience
Funded by
  • BlockScience
  • Metagovernance Project
Hosted at
  • BlockScience
Identifies via
Speaks protocol
Composes with
Basis for
Conforming implementations
Protocol spoken by