> ## Documentation Index
> Fetch the complete documentation index at: https://docs.timepointai.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Core Concepts

> Key concepts in the Timepoint ecosystem — timepoints, SNAG, temporal modes, and the Clockchain.

# Core Concepts

## Timepoints

A Timepoint is a verified, confidence-scored node in a temporal causal graph. It's a structured record of a moment — who was there, what they said, why it mattered, what happened next.

Every timepoint has a **canonical spatiotemporal URL** — 8 segments encoding *when* and *where*:

The 8 segments are, from left to right: year (negative for BCE), month, day, time (24-hour), country, region, city, and slug.

```
/-44/march/15/1030/italy/lazio/rome/assassination-of-julius-caesar
  │    │    │   │     │     │    │    └── slug
  │    │    │   │     │     │    └─────── city
  │    │    │   │     │     └──────────── region
  │    │    │   │     └───────────────── country
  │    │    │   └───────────────────── time (24hr)
  │    │    └───────────────────────── day
  │    └────────────────────────────── month
  └─────────────────────────────────── year (negative = BCE)
```

This path is both the node's primary key and its API address.

## SNAG (Social Network Augmented Generation)

SNAG synthesizes and maintains structured social graphs to ground LLM generation in complex group dynamics. Where RAG answers questions from what was written down, SNAG reasons about what people *did*, *felt*, and *caused*.

**19 composable mechanisms** handle entity states, knowledge provenance, dialog steering, emotional dynamics, relationship tracking, and more. Each mechanism can be enabled/disabled independently.

## Temporal Modes

Timepoint supports five temporal reasoning modes:

| Mode            | Description                    | Use Case                                   |
| --------------- | ------------------------------ | ------------------------------------------ |
| **FORWARD**     | Strict forward causality       | Standard timelines, "what happens next"    |
| **PORTAL**      | Backward from target outcome   | Goal decomposition, "how did we get here"  |
| **BRANCHING**   | Counterfactual branches        | "What if" analysis, alternate histories    |
| **CYCLICAL**    | Future constrains past         | Feedback loops, self-fulfilling prophecies |
| **DIRECTORIAL** | Dramatic tension drives events | Narrative arcs, screenplay generation      |

## Content Layers

The Clockchain stores moments at increasing levels of detail:

| Layer | Content                                            | Source                      |
| ----- | -------------------------------------------------- | --------------------------- |
| 0     | URL path + event name                              | Clockchain (auto-generated) |
| 1     | Metadata: figures, tags, description               | Clockchain expander (LLM)   |
| 2     | Full rendered scene with dialog, characters, image | Flash renderer              |

## Edge Types

Moments are connected by typed causal edges:

| Type              | Meaning                    | Auto-linked?            |
| ----------------- | -------------------------- | ----------------------- |
| `causes`          | Direct causal relationship | No — expander or manual |
| `contemporaneous` | Same year (+/- 1)          | Yes                     |
| `same_location`   | Matching geography         | Yes                     |
| `thematic`        | Overlapping tags           | Yes                     |

Each edge tightens the Bayesian prior — fewer plausible things *could* have happened in the gaps.

## Temporal Navigation

Because edges are typed and directed, the graph can be traversed *through time*, not just across it. Temporal navigation walks multiple hops from an anchor moment toward its causes (past) or consequences (future), or finds the shortest chain of connections linking two moments. Edge direction maps to temporal direction like this:

| Direction | Traverses (edges stored source → target)                                         |
| --------- | -------------------------------------------------------------------------------- |
| `future`  | Out-edges of `causes`/`precedes`/`influences`; in-edges of `caused_by`/`follows` |
| `past`    | Out-edges of `caused_by`/`follows`; in-edges of `causes`/`precedes`/`influences` |
| `both`    | Union of the two                                                                 |

Symmetric edge types (`contemporaneous`, `same_location`, `thematic`, and friends) have no temporal direction — they traverse both ways and are only followed when explicitly requested. This powers the [graph traversal API](/api-reference/clockchain#graph-traversal), the `traverse_moments` and `find_path` [MCP tools](/api-reference/mcp#temporal-navigation-tools), and the [Temporal Navigator](/products/clockchain#temporal-navigator) in the web app.

## TDF (Timepoint Data Format)

JSON-LD interchange format connecting all services. Every TDF record includes:

* **id** — canonical URL or service UUID
* **source** — which service produced it (flash, clockchain, proteus, snag-bench)
* **provenance** — generator, run ID, confidence score
* **payload** — source-specific content
* **tdf\_hash** — SHA-256 of canonicalized payload for content addressing

## Gateway

The API Gateway (`api.timepointai.com`) is the entry point for all client traffic. It owns authentication (Apple, Google, and GitHub OAuth), JWT signing and verification, credit management, and user accounts. Generation requests are proxied to Flash with an `X-User-ID` header — Flash itself runs with authentication disabled as a pure generation engine.

## MCP (Model Context Protocol)

The Clockchain exposes a Model Context Protocol endpoint at `clockchain.timepointai.com/mcp/` (Streamable HTTP, v1.26.0). This allows MCP-compatible clients — Claude Desktop, Cursor, and other LLM tools — to query and traverse the temporal causal graph directly as a tool call.

## Conductor

The **Conductor** is the unified natural-language interface to the whole Timepoint stack. Rather than calling each service's API directly, you (or an agent) tell the Conductor what you want in plain language — *find money, run a simulation, render a moment, explore the graph* — and it routes to the right services, runs and monitors long jobs, recovers from failures, and reports the credits it spends as it goes.

It is the authenticated home of `app.timepointai.com` and is available over both REST and an MCP `converse` tool at `conductor.timepointai.com/mcp`, so a single endpoint can drive the entire suite. Like everything else, it routes through the Gateway, so auth and credit metering stay centralized. See [Conductor](/products/conductor).

## The Flywheel

The system forms a self-reinforcing loop:

1. **Gateway** authenticates users and routes generation requests
2. **Flash** renders historical moments into grounded scenes
3. **Clockchain** stores them as graph nodes with causal edges
4. **Expander** (LLM) discovers related moments and grows the graph
5. **SNAG-Bench** scores quality across all outputs
6. More data → stronger Bayesian prior → better renderings → more data