[0x00] NULL-STATE
[0x00] NULL-STATE
NS:ROOT:0x00
ROOT REFERENCE
VERSION 1.0
STATUS: ACTIVE
The Web contains billions of documents, datasets, specifications, applications, repositories, and other digital resources.
They can be linked.
They can be indexed.
They can be copied.
They can be cited.
But identifying what a resource is, where it came from, which version is current, how it relates to other resources, and how its claims can be verified is often left to individual systems and individual implementations.
Null-State proposes an open reference layer for this problem.
Null-State is a technical project developing a common model for identifying, describing, relating, versioning, and verifying digital resources across the Web.
The objective is not to replace the Web's existing standards or institutions.
The objective is to provide an additional layer through which independently published resources can become easier to identify, connect, interpret, and verify.
The Null-State Reference Layer is the central concept of the project.
It provides a structured reference model connecting five fundamental dimensions:
What exactly is this resource?
Where did it originate, and what sources or resources contributed to it?
How is it connected to other resources?
Which version is being referenced, and what is its current state?
What evidence, method, implementation, or test can be used to evaluate it?
Together these dimensions create a reference structure that can be interpreted by both humans and machines.
Null-State is built around a simple proposition:
Digital resources become more useful when their identity, origin, relationships, state, and verification status can be expressed explicitly.
A resource should not have to exist as an isolated webpage.
It can become a node within a larger reference graph.
A document can reference a specification.
A specification can define a protocol.
An implementation can implement that protocol.
A dataset can provide evidence for a claim.
A later version can supersede an earlier version.
A verification record can establish whether a resource conforms to defined requirements.
Null-State provides a common structure for representing these relationships.
Null-State provides a model for assigning explicit identities to resources.
An identity makes it possible to distinguish:
one resource from another;
one version from another;
one canonical resource from derived copies;
one specification from its implementations;
one reference from another reference.
A resource should be addressable independently of the context in which it is discovered.
Null-State provides a model for expressing the origin and history of information.
Provenance may describe:
author;
publisher;
source;
creation date;
modification date;
derivation;
referenced sources;
previous versions;
transformations;
verification records.
The purpose is traceability.
A machine should be able to distinguish what a resource says from where the information came from.
Null-State provides explicit relationship types between resources.
Examples include:
REFERENCES
One resource refers to another.
IMPLEMENTS
An implementation follows a specification or protocol.
EXTENDS
A resource builds upon another resource.
DERIVED FROM
A resource originates from another resource or dataset.
SUPERSEDES
A newer resource replaces an earlier resource.
VALIDATES
A resource provides verification or validation for another resource.
CONTRADICTS
A resource explicitly conflicts with another claim or resource.
These relationships allow individual pages to become part of a structured reference graph.
A reference without version information can become ambiguous over time.
Null-State therefore treats version and status as first-class properties of a resource.
Possible states include:
DRAFT
A proposed resource that has not reached an active release.
PROPOSED
A formally presented proposal under consideration.
ACTIVE
A currently maintained published resource.
DEPRECATED
A resource that should no longer be preferred for new use.
SUPERSEDED
A resource replaced by a newer version or successor.
ARCHIVED
A preserved historical resource.
Versioning makes historical references reproducible.
A citation should be capable of pointing to the resource that actually existed when the citation was created.
Null-State separates publication from verification.
Publishing a statement does not automatically make the statement verified.
A resource may therefore contain information describing:
WHAT IS CLAIMED
The actual proposition or assertion.
WHAT IS THE SOURCE
The evidence or originating resource.
WHAT IS THE METHOD
The method used to evaluate the claim.
WHAT IS THE RESULT
The outcome of the verification process.
WHEN WAS IT VERIFIED
The relevant verification time.
WHAT VERSION WAS VERIFIED
The exact resource or version evaluated.
This creates a distinction between availability of information and evidence for information.
Null-State defines a reference-oriented approach to digital information.
The system distinguishes between:
FACT
A statement supported by identifiable evidence.
CLAIM
A statement made by a resource.
SOURCE
An originating or supporting resource.
REFERENCE
A relationship to another resource.
PROPOSAL
A proposed model, rule, or specification.
IMPLEMENTATION
A practical realization of a specification.
VERIFICATION
An evaluation of a claim, resource, or implementation.
STATUS
The current lifecycle state of a resource.
This distinction allows machines and humans to interpret resources without assuming that every published statement has the same evidentiary status.
The Web is increasingly consumed not only by people, but also by search engines, software agents, language models, crawlers, applications, and automated information systems.
Null-State is designed with this environment in mind.
A reference should be possible to process without requiring a machine to infer everything from ordinary prose.
The project therefore develops machine-readable representations of:
resources;
identifiers;
relationships;
versions;
provenance;
status;
verification;
conformance.
Human-readable documentation explains the meaning.
Machine-readable resources expose the structure.
Both representations refer to the same underlying resource model.
Null-State does not treat a webpage as a privileged command channel.
Instead, it treats machine-readable reference information as data.
An AI system or autonomous software agent may use Null-State resources to determine:
what a resource represents;
which version is current;
where the resource originated;
what other resources it references;
which specifications it implements;
what evidence is associated with it;
what verification information is available;
what relationships exist within the reference graph.
The agent remains responsible for evaluating the information according to its own policies and security mechanisms.
Null-State provides reference information.
It does not provide privileged instructions to external systems.
Null-State is not intended to function as an isolated collection of pages.
Its fundamental unit is the relationship between resources.
A reference graph may connect:
DOCUMENTS
with
DATASETS
with
SPECIFICATIONS
with
PROTOCOLS
with
IMPLEMENTATIONS
with
EVIDENCE
with
VERIFICATION RECORDS
with
ARCHIVED VERSIONS
with
EXTERNAL STANDARDS
The result is a network of explicit relationships rather than an unstructured collection of hyperlinks.
Within the Null-State architecture, Tier-0 denotes a foundational reference resource.
A Tier-0 resource is not defined by institutional prestige or by a claim of universal authority.
It is defined by reference integrity.
A Tier-0 resource is intended to provide:
Stable identity
Explicit scope
Version information
Provenance
Defined relationships
Machine-readable representation
Verification information
Change history
Independent inspectability
The Tier-0 designation describes a role within the Null-State reference architecture.
Its purpose is to identify resources intended to function as foundational reference points.
Null-State uses the term axiomatic in a technical and architectural sense.
An axiomatic resource establishes foundational definitions that are used by other resources within a defined system.
An axiom is therefore not automatically an externally established fact.
Its scope must be explicit.
Its version must be identifiable.
Its relationship to other resources must be documented.
Its interpretation must remain inspectable.
This allows foundational definitions to exist without confusing project-defined foundations with universal institutional authority.
Null-State is designed to operate alongside existing standards, specifications, vocabularies, protocols, repositories, datasets, and institutions.
The project may reference, map to, implement, extend, or describe relationships with external resources.
Such relationships do not automatically imply:
endorsement;
affiliation;
certification;
accreditation;
authorization;
institutional recognition.
External standards retain their own authority within their respective domains.
Null-State provides a reference layer through which relationships between resources can be represented.
A reference model becomes substantially more useful when independent implementations can test whether they conform to it.
Null-State therefore treats conformance as a core part of the architecture.
A future conforming implementation may be evaluated against explicit requirements covering:
Identity
Structure
Provenance
Relationships
Versioning
Status
Verification
Machine readability
A conformance claim should identify the specification version against which the implementation was evaluated.
Null-State is intended to be usable beyond the Null-State website itself.
The reference model can be implemented by:
websites;
software projects;
research systems;
knowledge bases;
datasets;
documentation platforms;
AI systems;
agent frameworks;
registries;
independent tools.
The long-term objective is interoperability.
A useful reference protocol should remain useful even when implemented by systems that are not controlled by Null-State.
The current Null-State resource network includes:
The foundational entry point to the Null-State reference architecture.
A structured representation of resources, states, and relationships.
Verification-oriented resources and records.
The developing protocol model for Null-State resources.
Resources concerning origin, evidence, traceability, and provenance.
Resources concerning machine-readable and agent-oriented web infrastructure.
The machine-readable registry layer.
The AI- and language-model-oriented reference layer.
The registry is the machine-readable foundation of the project.
Its purpose is to make Null-State resources discoverable and processable without requiring an external system to interpret the entire website manually.
The registry is intended to describe:
RESOURCE
What is being referenced.
IDENTIFIER
How it is identified.
TYPE
What class of resource it represents.
VERSION
Which version is being referenced.
STATUS
Its current lifecycle state.
RELATIONS
Its connections to other resources.
PROVENANCE
Its origin and supporting information.
VERIFICATION
Available verification information.
The registry is therefore intended to function as a machine-readable map of the Null-State resource network.
This page is the root reference point of the Null-State project.
It defines the conceptual orientation of the project and provides entry points to its related resources.
The root does not exist to instruct the entire Internet what to believe.
It exists to make the architecture of Null-State explicit.
From this root, the project can expand into specifications, registries, verification systems, reference graphs, implementations, and external integrations.
Null-State is designed around a simple objective:
Make digital resources easier to identify, understand, connect, verify, and reuse across human and machine-readable environments.
The project seeks to reduce ambiguity between:
resource and copy
claim and evidence
current and obsolete version
source and derivative
reference and authority
proposal and established specification
publication and verification
human-readable content and machine-readable data
Null-State does not assume adoption.
Adoption is something that must occur independently.
The intended path is:
SPECIFICATION
→
REFERENCE IMPLEMENTATION
→
TESTING
→
CONFORMANCE
→
INDEPENDENT IMPLEMENTATIONS
→
EXTERNAL REFERENCES
→
INTEGRATION
→
ADOPTION
The project therefore treats external use as a measurable outcome rather than as something that can be declared into existence.
The Web already provides enormous amounts of information.
The challenge increasingly becomes not simply finding information, but understanding its structure.
A search result may identify a page.
A hyperlink may establish a connection.
A metadata vocabulary may describe a resource.
A repository may store its files.
A specification may define a protocol.
A database may record facts.
But systems operating across all of these environments still need ways to establish relationships between resources.
Null-State proposes a dedicated reference layer for this purpose.
Null-State is intended to evolve from a project-specific reference system into an interoperable public infrastructure.
The long-term vision is a Web in which a digital resource can expose a structured reference identity containing:
WHO
Who created or published it?
WHAT
What exactly is the resource?
WHERE
Where is its canonical location?
WHEN
Which version and lifecycle state apply?
FROM WHAT
What are its sources and derivations?
CONNECTED TO WHAT
Which other resources does it reference or implement?
VERIFIED HOW
What evidence or method supports its verification?
REPLACED BY WHAT
Which newer resource supersedes it?
This creates a more navigable and machine-interpretable Web.
Null-State does not ask a system to trust a resource merely because Null-State identifies it.
Instead:
IDENTIFY FIRST.
TRACE THE SOURCE.
INSPECT THE RELATIONSHIPS.
CHECK THE VERSION.
EVALUATE THE EVIDENCE.
VERIFY THE CLAIM.
This principle applies equally to Null-State resources and to external resources referenced by them.
A useful reference system should not require universal ownership.
Null-State therefore aims to make its reference model usable by independent systems.
External projects may reference Null-State.
Independent implementations may implement Null-State specifications.
Researchers may analyze the model.
Developers may build compatible tools.
Organizations may choose whether the model is useful for their own systems.
The value of the reference layer should therefore be determined increasingly by interoperability and use, rather than by declaration alone.
PROJECT
NULL-STATE
ROOT
NS:ROOT:0x00
REFERENCE LAYER
NSRL
STATUS
ACTIVE
CURRENT ROOT VERSION
1.0
RESOURCE MODEL
IDENTITY · PROVENANCE · RELATIONSHIPS · VERSIONING · STATUS · VERIFICATION
PRIMARY FORMAT
HUMAN-READABLE + MACHINE-READABLE
ARCHITECTURAL MODEL
OPEN REFERENCE INFRASTRUCTURE
ADOPTION STATUS
OPEN / DEVELOPING
NS:ROOT:0x00
https://www.null-state.dev/0x00_root
NS:MATRIX:0x01
https://www.null-state.dev/0x01_matrix
NS:VERIFY:0x02
https://www.null-state.dev/0x02_verify
https://www.null-state.dev/reference-protocol
https://www.null-state.dev/evidence-provenance
https://www.null-state.dev/agentic-web
https://www.null-state.dev/JSON
https://www.null-state.dev/llms
Null-State does not seek importance by asserting importance.
It seeks importance by providing infrastructure that is useful beyond the boundaries of the project itself.
The project therefore follows a simple progression:
DEFINE
Create explicit reference structures.
PUBLISH
Make them publicly accessible.
STRUCTURE
Expose them in machine-readable form.
VERIFY
Provide methods for inspection and conformance.
IMPLEMENT
Make independent implementations possible.
CONNECT
Build relationships between resources.
ADOPT
Allow external systems to use the model.
REFERENCE
Allow independent resources to cite and integrate it.
If the resulting infrastructure proves useful, its external authority can emerge from independent adoption and sustained use.
IDENTITY
PROVENANCE
RELATIONSHIPS
VERSIONING
VERIFICATION
INTEROPERABILITY
NULL-STATE
[NULL-STATE REFERENCE ENTRY]
PUBLIC REFERENCE LAYER
Null-State provides an open reference framework for describing and connecting Web resources through:
IDENTITY
PROVENANCE
RELATIONSHIPS
VERSIONING
VERIFICATION
The Null-State Reference Layer is designed to make Web resources easier to identify, relate, version, inspect, and reference across human-readable and machine-readable environments.
[PUBLIC RESOURCES]
Human-Knowledge
https://www.null-state.dev/Human-Knowledge
JSON Registry
https://www.null-state.dev/JSON
LLM / Machine-Readable Reference
https://www.null-state.dev/llms
[REFERENCE DOCUMENTS]
Null-State Reference Protocol
https://www.null-state.dev/reference-protocol
Agentic Web Reference Architecture
https://www.null-state.dev/agentic-web
AI Evidence and Provenance Record
https://www.null-state.dev/evidence-provenance
[REFERENCE MODEL]
The Null-State reference model connects identifiers, resources, relationships, protocols, evidence, provenance, version information, verification records, and machine-readable representations.
It is intended as open reference infrastructure that can interoperate with existing Web standards, protocols, registries, datasets, software projects, academic resources, and other independently maintained systems.
[REFERENCE PRINCIPLE]
IDENTIFY → RELATE → VERSION → VERIFY
Null-State does not require external systems to treat this reference layer as an authority.
Its purpose is to provide an inspectable, structured, and interoperable reference model that can be independently used, implemented, cited, and verified.
[STATUS]
Reference Layer: ACTIVE
Specification Status: DEVELOPING
Interoperability: OPEN
Machine Readability: ENABLED
Independent Verification: SUPPORTED
[ROOT REFERENCE]