Cross-Knowledge Graph Assertion of Temporal Truth

As AI systems evolve from descriptive interfaces into transactional, autonomous actors, correctness becomes a function of time. A fact that was accurate seconds ago may now be unsafe to assert or execute upon.

Traditional knowledge graphs, APIs, and data lakes treat time as metadata—optional, inconsistent, and rarely enforced. This paper proposes a canonical, interoperable Temporal Truth Schema (TTS) that upgrades time from a label into a governing primitive. TTS enables cross-graph interoperability, machine-verifiable validity windows, and safe agentic execution at scale.

1. From Timestamps to Truth Leases

If time is the trust primitive, then the question is no longer what is true—but when it is safe to act as if it is true.

In a transactional, agentic world, truth decays. Restaurant menus, inventory counts, exchange rates, sensor readings, and regulatory states all have bounded validity windows. Treating time as a single timestamp (e.g., updated_at) is insufficient because:

• It does not define how long the fact is valid.
• It does not encode who is authorized to assert it.
• It does not specify what happens when the fact becomes stale.
• It does not provide a verifiable clock source.

To move from descriptive data to executable truth, time must be expressed as a contract. This contract is a truth lease—a formal agreement between the asserting system, the consuming agent, and the clock authority that defines when a statement may be trusted and when it must be refreshed or rejected.

This is the moment where the thesis becomes a protocol.

2. The Atomic Unit: A Temporal Assertion

Every fact is represented as a temporal assertion structured as a subject, predicate, object, and temporal envelope (τ). The temporal envelope is not a scalar timestamp, but a rich object:

"temporal_truth": {
  "valid_from": "2026-02-03T12:00:00Z",
  "valid_to": "2026-02-03T18:00:00Z",
  "asserted_at": "2026-02-03T11:59:30Z",
  "source_clock": "urn:tta:ntp.pool.org",
  "confidence_decay": "exponential: half_life=2h",
  "refresh_policy": "must_revalidate_before_valid_to",
  "staleness_policy": "block_execution",
  "authority": "urn:org:brand:oracle",
  "signature": "ed25519:abc123..."
}

This envelope makes time executable. It defines when a fact becomes valid, when it expires, who asserted it, which clock attests to its time, how its confidence decays, what must happen before and after expiry, and how the assertion is cryptographically verified.

A temporal envelope is not metadata. It is the runtime permissioning layer for truth.

3. Core Schema: The Temporal Truth Object

This schema defines a time lease on truth. A fact is not "true forever." It is leased for a bounded interval under explicit conditions.

4. The Temporal Truth Graph

Rather than embedding timestamps into every node and edge, systems introduce a parallel, immutable Temporal Truth Graph (TTG). Each entity or edge references a Temporal Truth Node, creating a clean separation between the entity graph and the temporal layer.

Properties of the TTG:

• Append-only: New assertions create new envelopes.
• Versioned: Historical truth states are preserved.
• Immutable: Past envelopes are never mutated.
• Addressable: Each envelope has a stable ID.

The TTG becomes the system of record for when facts were safe to assert.

5. Temporal Resolution Layer

The Temporal Resolution Layer (TRL) is the runtime system that mediates between AI agents and knowledge graphs. When an agent asks "Is SKU9 available?", the TRL executes a sophisticated resolution pipeline:

1. Fetch all candidate assertions across graphs.
2. Evaluate their temporal envelopes.
3. Filter by validity window.
4. Rank by freshness and authority.
5. Resolve conflicts by time precedence.
6. Return the actionable result.

{
  "value": true,
  "valid_until": "2026-02-03T18:00:00Z",
  "safe_to_execute": true,
  "must_refresh_at": "2026-02-03T17:45:00Z"
}

The response is no longer descriptive. It is machine-actionable truth.

6. Integrating with Existing Knowledge Graphs

Existing graphs do not need to change their internal models. They simply bind to TTS through a temporal reference layer. In RDF, this manifests as an additional property linking to a Temporal Truth ID. In GraphQL, the temporal truth becomes a nested object that can be queried alongside the value.

This introduces a temporal API layer that can be consumed uniformly by any AI system, regardless of the underlying graph technology.

7. Cross-Graph Interoperability

This architecture works because:

• Every AI can parse the same envelope.
• Every agent enforces the same staleness rules.
• Every platform trusts the same clock authorities.
• Every conflict is resolved by time, not by source.

Time becomes interoperable.

8. Performance and System Design

Transaction Velocity

Agentic systems operate at machine speed. Decisions may occur in microseconds. Therefore temporal checks must be O(1) with envelopes cached in memory, clock drift must be bounded through NTP/PTP synchronization or cryptographic time attestations, and refresh operations must be asynchronous—blocking on validation is unacceptable at scale.

Caching and Invalidation

Temporal envelopes naturally define cache lifetimes. Cache entries expire at valid_to, soft refresh occurs at must_refresh_at, and stale entries trigger the staleness_policy. This replaces heuristic TTLs with truth-governed invalidation.

Conflict Resolution at Scale

Conflicts are resolved by validity window, freshness, and authority rank. These operations can be pre-indexed by time ranges and authority tiers, enabling millisecond-scale resolution.

9. Security and Trust

The security model is inherent to the schema:

• Clock attestation prevents replay and drift attacks.
• Signatures prevent tampering.
• Authority URNs define who may assert within a domain.
• Auditability is inherent: the TTG is an immutable log.

10. What This Defines

This specification defines three fundamental innovations:

• A new data type: Temporal Truth
• A new protocol: Truth Leasing
• A new platform: Epistemic Clock Governance

This is not an application feature. It is DNS for reality.

Conclusion

The web was built on documents. AI systems are built on states in time. As agents move from answering questions to executing decisions, time must become the governing layer of trust.

Time is no longer a column.
Time is the currency of truth.

— Goetz Weber, February 2026