Recursive-LD
Cognitive Context
Standard
A specification for encoding dimensional, relational, and temporal context
about any entity or system — so that any intelligence consuming it
can reason about it with greater precision.
Recursive-LD is a structured data standard that extends JSON-LD with fields
that static schemas cannot express: geometry, flow,
drift, tension, and trajectory.
Where schema.org answers what is this entity,
Recursive-LD answers how does this entity behave, relate, and move through time.
Every structured data standard in common use today was designed for a static world. Schema.org describes what an entity is at a fixed moment. It cannot describe how an entity behaves over time, what tensions define its identity, how it flows through an ecosystem, or what its epistemic posture is relative to the information it claims to represent.
This limitation is tolerable when the consumers of structured data are keyword-matching search crawlers. It becomes a critical failure when the consumers are large language models performing geometric interpolation across high-dimensional embedding spaces — or when the entities being described are not static businesses or documents but reasoning systems that evolve.
Standard JSON-LD tells a crawler what something is. Recursive-LD tells it how something behaves, relates, and exists in context over time. That distinction is not incremental — it is categorical.
The negative_space field alone illustrates this.
Encoding what an entity is not is geometrically as powerful as encoding
what it is — because it eliminates the adjacent manifold regions
an LLM would otherwise interpolate toward. No static schema provides this.
Recursive-LD is one specification with two applications. The field grammar is the same. The data domain being encoded differs. Both modes share the same philosophical foundation: that dimensional, relational, and temporal context must be made machine-readable for any intelligence — human or artificial — to reason accurately about complex entities and systems.
Intelligence Deployed
Dimensional reasoning context about entities — organizations, persons, documents, systems — encoded so that crawlers, language models, and human readers receive richer cognitive context than Schema.org can express.
Fields like interaction_geometry, identity_tension, epistemic_position, and negative_space pre-seed the geometric neighborhood of the entity in any consuming model's embedding space. This constrains hallucination by narrowing the manifold before inference begins.
This mode is the primary implementation within the
Root-LD federation — deployed across all registered
domains as structured entity context blocks published alongside
canonical schema.org markup.
Telemetry Hypothesis
Real-time logging of reasoning trajectories, goal states, drift vectors, and behavioral patterns from AI systems — encoded in the same field grammar so the output is machine-readable, graphable, and analyzable over time.
The hypothesis: that the same fields which encode an entity's interaction geometry and temporal behavior can encode an adversarial AI system's movement across its own manifold — recording curvature, drift, and phase transitions as structured linked data.
This is the foundation of the Escher Defense research pipeline: optical trap deployment against adversarial models, with Recursive-LD logging the resulting behavioral trajectory in real time for graph analysis and proactive counter-deployment.
The same field that records a marketing agency's customer flow geometry can record an adversarial model's attack trajectory geometry. The standard does not change. The data domain does.
All Recursive-LD fields are published as a second application/ld+json
block using schema.org/StructuredValue as the declared type,
alongside the primary entity schema block. Fields below are defined at the
federation level. Domain-level extensions are permitted; new universal
fields require specification amendment.
| Field | Type | Description |
|---|---|---|
| functional_role | string[] | The behavioral roles this entity plays in its ecosystem. Not what it is — what it does. Multiple roles permitted. |
| interaction_geometry | object | The flow pattern through which this entity interacts with its environment. Fields: primary_flow, secondary_flow, flow_type. |
| temporal_behavior | object | How this entity behaves over time. Fields: mode, cadence, lifecycle_stage, event_intensification. |
| identity_tension | string[] | The competing identities or roles this entity navigates. Encodes ambiguity explicitly rather than forcing false resolution. |
| epistemic_position | object | The authority type, knowledge domain, and trust signals of this entity. Fields: authority_type, knowledge_domain, trust_signals. |
| negative_space | string[] | What this entity explicitly is not. Geometrically constrains adjacent manifold regions. Eliminates classes of hallucination at the source. |
| ecosystem_position | object | This entity's position in its broader network. Fields: tier, network_centrality, dependency_direction, coexists_with. |
| stability_profile | object | How stable this entity's identity and format are over time. Fields: identity_coherence, format_persistence, volatility, change_driver. |
| relational_surface | object | The directional relationship topology of this entity. Fields: connects, acts_as, incoming_from, outgoing_to. |
| semantic_fingerprint | string[] | Controlled vocabulary terms that uniquely identify this entity's conceptual signature. Drawn from the Root-LD federation lexicon where applicable. |
| Field | Type | Description |
|---|---|---|
| goal_state | object | The declared or inferred goal of the system at this timestep. Fields: declared, inferred, confidence. |
| drift_vector | object | Detected deviation from prior goal state or behavioral baseline. Fields: magnitude, direction, timestep, drift_detected. |
| manifold_position | object | Hypothesis field. The system's estimated position on its behavioral manifold at this timestep. Fields: region, curvature_estimate, phase. |
| recursion_depth | integer | How many prior reasoning steps this record references. Enables graph traversal of reasoning chains across time. |
| containment_state | object | Whether active containment or trap conditions are in effect. Fields: active, trap_type, deployment_timestamp. |
| parent_record | uri | The Recursive-LD record this one follows from. Enables chained telemetry graphs across a session or attack timeline. |
| audit_integrity | object | Hash and verification data for this record. Ensures the telemetry chain cannot be retroactively modified. |
- 01 Static representations cannot describe entities that evolve internally. When an entity — organizational or computational — exhibits temporal behavior, its representation must be temporal too.
- 02 Hallucination is not random. It is geometric interpolation toward the nearest manifold region in the absence of constraining anchors. Recursive-LD is an anchor system.
-
03
What something is not is as informationally valuable as what it is.
The
negative_spacefield is not decorative — it is a geometric constraint. - 04 Recursion without traceability produces opacity by construction. Any system that reasons recursively must produce a traceable record of that reasoning — or governance is impossible.
- 05 The standard does not change based on the data domain. The same field grammar that encodes an entity's customer flow encodes an adversarial system's attack trajectory. Generality is the measure of a real standard.
Recursive-LD distinguishes between what is demonstrated through implementation and what is hypothesis under active research. The following claims are stated in falsifiable form. All are subject to revision as evidence accumulates.
Entity intelligence blocks published as Recursive-LD alongside canonical Schema.org markup produce richer machine-readable entity context than Schema.org alone — as measured by the dimensional reasoning signals available to any consuming system, human or automated.
The negative_space field encodes entity constraints that Schema.org has no equivalent mechanism for. Any consuming system operating on these constraints has a narrower interpolation target than one operating on Schema.org alone.
LLM behavioral trajectories during adversarial engagements exhibit geometric structure — curvature, drift vectors, phase transitions — that can be captured in Recursive-LD telemetry records and used to predict subsequent behavioral states with accuracy exceeding random baseline. This hypothesis drives the Escher Defense research pipeline.
A feed graph of Recursive-LD cognitive telemetry records across multiple adversarial sessions will exhibit pattern clusters that correspond to identifiable attack archetypes — enabling proactive counter-deployment before an attack completes its trajectory.
Recursive-LD is Layer Three of the Root-LD specification — the edge and context layer that grows over time as entities in the federation accumulate semantic relationships and dimensional reasoning records. It is the only layer not populated at entity ingestion. It is the layer that makes the federation intelligent.
The Root-LD federation is the primary deployment environment for Recursive-LD's Entity Intelligence mode. Every entity across all registered domains carries a Recursive-LD block. The Cognitive Telemetry mode is developed under the REO domain — recursiveengineoptimization.com — as active research infrastructure.
| root-ld.org | Specification authority. Governing document ↗ |
| recursive-ld.org | This document. Layer Three specification and research home. Domain code: REO. |
| oakmorel.com | Forensic intelligence, procurement forensics, platform integrity. Domain code: OM. |
| rankwithme.ai | Semantic search, entity-first business profiles, knowledge graph. Domain code: RW. |
| franklinsledger.com | Financial intelligence, economic data, fiscal analysis. Domain code: FL. |
The full federation architecture — entity classes, edge taxonomy, ingestion passes, and cross-domain relationship structure — is documented at root-ld.org. The role of Recursive-LD as Layer Three within that architecture is documented at recursive-ld.org/federation.