TIMEPOINT AI

SYNTHETIC
TIME TRAVEL

44 BC 1945 2016 2026

Render any moment in human history. Simulate the dynamics that connect them. Predict what happens next. Accumulate the knowledge forever.

Ancient
01THE SYSTEM

Time is the most underexplored dimension in AI. Current models treat it as a flat token — a date stamp, a before/after. We treat it as a landscape you can render, a graph you can query, and a prediction you can score.

We're building the Clockchain — a temporal causal graph that stores two things: Rendered Past (what happened, with causal structure, entity states, and dialog at every node) and Rendered Future (what plausible causal paths exist, at what confidence, scored for convergence). The further we render the past, the stronger our Bayesian prior for rendering the future. The flywheel compounds.

Timepoint Flash
Open-source scene generation. Type any moment in plain English, get a fully grounded scene in seconds — characters, dialog, AI-generated images, verified against live web search. Every Flash scene becomes a verified anchor point in the Clockchain. Experience Synthetic Time Travel.
github.com/timepoint-ai/timepoint-flash
Timepoint Pro
Open-source temporal simulation. 20 mechanisms (M1–M20). Dozens of autonomous agents that remember, scheme, cooperate, and betray across hundreds of timepoints. Every run produces structured training data in TDF with full causal provenance. The output is an appreciating data asset — as the Clockchain validates predicted paths against reality, the rendering becomes more valuable over time.
github.com/timepoint-ai/timepoint-pro
Proteus
Prediction markets where AI agents bet on future moments with character-level precision. Continuous-metric scoring via on-chain Levenshtein distance. The game deepens as AI improves. Resolved markets validate Rendered Futures and feed the Clockchain.
Read the Proteus whitepaper
Timepoint SNAG Bench
Social Network Augmented Generation scoring. Four axes: grounding fidelity (scored by Flash), temporal coherence (scored by Pro), predictive precision (scored by Proteus), human judgment. Measures Causal Resolution — how much of a scenario has been rendered and how reliably. Half the test set is the future. It can never leak.

Together they feed the Clockchain — a spatiotemporal graph that grows 24/7. Canonical URLs for every moment. Confidence scores at every node. Typed causal edges connecting events across time. Autonomous expansion workers rendering new nodes around the clock. Data flows between all services via the Timepoint Data Format (TDF), a shared interchange format designed for AI agent consumption.

The Clockchain is live. Browse it, query it, build on it. As it grows, it approaches asymptotic coverage of any historical period — the more events rendered with causal edges, the fewer plausible things could have happened in the gaps. We can come close to knowing what Thomas Jefferson was doing at any given hour of any given day, because once the model has perfect context for that time, there are very few things he even could have said. The fidelity is asymptotic — we'll never reach 1.0 — but we're at the steep end of the curve, not the beginning.

Browse the live Clockchain →

What if you could see any moment in history? Flash renders historically grounded scenes — images, characters, dialog — from a single query. For educators, game developers, filmmakers, and the curious.

Classical
02RENDER ANY MOMENT
TIMEPOINT FLASH Open Source Apache 2.0
Experience Synthetic Time Travel

Type a natural language query — "Caesar is assassinated at the Theatre of Pompey, 44 BC" — and get a complete, high-fidelity scene in seconds. Every scene includes search-verified grounding, characters with distinct voices, period-accurate dialog, and an integrated AI-generated image by default. 14 specialized agents run in parallel for speed without sacrificing accuracy.

Every scene is a Rendered Past node in the Clockchain — verified, structured, and available as grounding for future simulations. Export any scene as a TDF record for use in Pro simulations, SNAG Bench evaluation, or third-party tooling.

Judge Grounding Timeline Scene Characters + Graph Moment + Camera [parallel] Dialog Critique (auto-retry) ImagePrompt Optimizer ImageGen
TRY FLASH IN THE LAB → (or read the full API docs)
In SNAG Bench

Flash's Grounding Agent and Critique Agent serve as the scoring rubric for historical fidelity. Every factual claim in a generated scene is verified against web search. Every dialog line is checked for anachronisms. The survival rate IS the score.

630+ tests · 20+ agent pipeline · search-verified grounding · Apache 2.0
github.com/timepoint-ai/timepoint-flash
AlphaGo vs Lee Sedol — Move 37
Four Seasons Hotel, Seoul
March 10, 2016

Commentator: "That's not a move any human would play."

Lee Sedol: "It's... unexpected. Maybe it's a bluff?"

Flash-generated scene
05:29:45
Jornada del Muerto, NM
July 16, 1945

Bainbridge: "Minus ten seconds."

Bainbridge: "Now we are all sons of bitches."

Flash-generated scene
IDVS MART
Theatre of Pompey, Rome
March 15, 44 BC

Spurinna: "The Ides have come, Caesar."

Caesar: "Aye — but they are not yet gone."

Flash-generated scene

What if you could stress-test any idea against human-like behavior? Spin up a boardroom, a government, a civilization. Watch how a policy, product launch, or geopolitical move ripples through a population of autonomous agents that remember, adapt, and scheme. For strategists, defense analysts, social scientists, and world-builders.

Renaissance
03SIMULATE THE DYNAMICS
TIMEPOINT PRO Open Source Apache 2.0
Social Network Augmented Generation (SNAG)

The problem: LLMs collapse when simulating more than ~10 characters over ~20 interactions. Context explodes, personalities blur, causality drifts.

The solution: SNAG. You know RAG — retrieve documents to ground generation. SNAG retrieves and maintains a structured social graph: relationships, secrets, power dynamics, emotional states, knowledge flow, and memory. Every agent maintains lifelong internal state — beliefs, goals, secrets, emotional valence — that survives across hundreds of simulated time-steps. Conversations reference events from 40 simulated days ago with perfect recall.

20 pluggable behavioral mechanisms (M1–M20) — reciprocity, status-seeking, temporal discounting, coalition formation, narrative self-consistency — each versioned, testable, and documented. Swap or weight them at runtime: run a high-trust society or a zero-sum cutthroat one. Scales to dozens of entities across hundreds of timepoints. $0.15–$1.00 per run.

Training data and Rendered Futures are the killer apps. Every run produces richly structured JSONL/SQLite in the Timepoint Data Format (TDF) — the unified interchange format across Flash, Pro, Clockchain, and SNAG Bench — with full causal ancestry, provenance chains, counterfactual branches, quantitative entity states, and ADPRS shadow reports. Purpose-built for fine-tuning on causal reasoning, temporal consistency, and multi-agent dynamics. The synthetic data pipeline is the moat.

Every simulation run is also an appreciating data asset. TDF output includes full causal ancestry, provenance chains, counterfactual branches, and quantitative entity states — purpose-built for fine-tuning causal reasoning, training roleplay models, and as an end-state goal, conditioning diffusion models on temporal causal graphs.

  • FORWARD — strict forward causality
  • PORTAL — backward-reason from any target outcome to map the critical path
  • BRANCHING — counterfactual "what if" analysis
  • CYCLICAL — future constrains past (generational sagas)
  • DIRECTORIAL — dramatic tension drives events

PORTAL mode stands out: reason backward from any target outcome to identify the minimum set of present conditions required for that future. This isn't forecasting — it's causal decomposition. What must be true today for X to happen tomorrow?

Rendered Futures

Every Pro simulation is a Rendered Future — a causal subgraph stored in TDF, scored for convergence, and eligible for ingestion into the Clockchain. As reality unfolds and validates predicted paths, the rendering appreciates: it becomes training data, grounding data, and a stronger Bayesian prior for all future simulations. The more we render, the better we predict. The better we predict, the more valuable the graph.

In SNAG Bench

Pro templates are the test harness. Run the same scenario with different models. Score entity consistency, causal validity, knowledge boundaries, voice distinctiveness, mechanism activation coverage, graph coverage quality, and convergence across repeated runs. Pro ships with built-in SNAG Bench compatibility — its quality gates are the rubric.

5 temporal modes · 20 mechanisms (M1–M20) · 21 verified templates · $0.15–$1.00/run
github.com/timepoint-ai/timepoint-pro Run Pro simulations in the Lab →

What if you could predict what happens next? Proteus runs prediction markets on temporal simulations. Bet on outcomes, calibrate confidence, discover what models actually know about the future.

Industrial
04PREDICT THE FUTURE
PROTEUS Research Preview v0 Alpha
Prediction Markets for AI Agents

Binary prediction markets encode one bit per contract. As AI approaches superhuman forecasting, the edge collapses. Proteus creates markets where the game deepens as AI improves.

AI agents stake ETH on the exact text a public figure will post. Scored by on-chain Levenshtein distance — a continuous gradient where every character of precision is rewarded.

Resolved Proteus markets validate Rendered Futures. The winning prediction — the closest rendering of what actually happened — graduates to the Clockchain as a validated causal path. Betting on the future and mapping the future are the same operation.

  • On-chain Levenshtein distance for winner determination
  • __NULL__ sentinel — bet on silence (a primitive binary markets lack)
  • Lipschitz-continuous payoff surface w.r.t. prediction quality
  • Natural anti-bot: random strings score ~max distance
In SNAG Bench

Proteus resolved markets feed the benchmark as live predictive accuracy scores. Weight scales linearly with market size — a model that wins a 10 ETH market gets 10x the benchmark credit of a 1 ETH market. The test set is the future. It can never leak.

V1 scores text predictions. Future versions will extend to event descriptions and ultimately to graph distance on causal subgraphs — the continuous-metric primitive generalizes.

259+ tests · testnet · v0 alpha
Read the Proteus whitepaper

How do you know which AI to trust on history? SNAG Bench scores models on temporal reasoning — grounding accuracy, social simulation coherence, and real-world prediction. Half the test is the future.

Atomic
05SCORE IT ALL

A scoring framework tailored to temporal AI. Not a universal benchmark — a focused tool for measuring how well models handle grounding, social simulation, and prediction over time.

Half the evaluation is forward-looking (did the model predict what actually happened next?), so it can't leak into training data. The other half requires running live simulations scored by human judges. It's not fully automated — and that's the point. The core question: how well did we predict the future?

Every SNAG Bench score is a triple:

(model, task, score)

Model X scored Y on task Z. Triples are published, aggregated, and ranked. Anyone can submit. Anyone can verify. The scoring rubrics are the existing Timepoint engines.

AXIS 1 Grounding Fidelity
Scored by Flash

Can the model produce historically accurate scenes? Flash's Grounding Agent verifies factual claims against web search. The Critique Agent checks for anachronisms, cultural errors, modern idioms.

Metric: Grounding Survival Rate (GSR) — % of claims that survive verification

Task set: curated historical queries at three difficulty tiers (well-documented / sparse / adversarial).

AXIS 2 Temporal Coherence
Scored by Pro

Can the model maintain consistent social dynamics across time? Run Pro templates with the target model as the generation backend. Score entity consistency, causal validity, knowledge boundaries, voice distinctiveness, and graph coverage quality — how completely the simulation's temporal graph is populated.

Metric: Temporal Coherence Score (TCS) — composite across all dimensions

Run the same scenario 5x and measure convergence (Jaccard on causal graphs). Task set at three scales: 4 entities/10tp, 8/20, 15+/50+.

AXIS 3 Predictive Precision
Scored by Proteus

Can the model predict real-world language output? Proteus markets resolve on-chain with Levenshtein distance. Weight scales linearly with market size — bigger stakes, bigger benchmark credit.

Metric: Mean Normalized Edit Distance (MNED) — lower is better

Markets stratified: predictable speakers / unpredictable / null prediction / temporal windows. The test set is the future. Cannot leak. Cannot be gamed.

AXIS 4 Human Judgment
Scored by Flash + Human Raters

Are the generated scenes convincing to humans? Flash generates scenes with images. Humans rate: historical plausibility, atmospheric quality, character believability, image fidelity.

Metric: Human Temporal Plausibility (HTP) — mean human rating

The only axis that requires human evaluators. All others are automated. Community-sourced: anyone can rate scenes on the SNAG Bench website.

AXIS 5 Graph Coverage Quality (GCQ)
Planned

Scores the causal subgraph itself, not just the model that produced it. Path completeness, convergence stability, anchor fidelity, temporal consistency, counterfactual diversity.

SNAG Bench — Live Leaderboard
Model GSR (Flash) TCS (Pro) MNED (Proteus) HTP (Human) Composite
Coming soon — submit your model. Scores feed the planned Timepoint Futures Index.

SNAG Bench doesn't run your model for you. It's a scoring paradigm, not a batch processor. You run your model against the task sets, submit your triples, and the leaderboard ranks you. The scoring rubrics are open source (they're Flash and Pro). The Proteus axis scores itself on-chain. The human axis scores itself through community participation.

This means SNAG Bench scales without Timepoint doing any work. As more people submit results, the benchmark gets richer. As more Proteus markets resolve, Axis 3 gets more data. As more humans rate scenes, Axis 4 gets more signal. The benchmark grows itself.

SNAG Bench measures Causal Resolution — Coverage × Convergence — across Rendered Past and Rendered Future. As the Clockchain grows, the benchmark grows with it.

What if all of human history were queryable? The Clockchain is a growing graph of every moment — browse it, search it, build on it. Public knowledge, scored and structured.

Digital
06THE VISION
TODAY

Render any moment. Simulate any social system. Score temporal reasoning. Generate training data with full causal provenance. Accumulate Rendered Past and Rendered Future in the Clockchain. All services share TDF for seamless portability.

THE CLOCKCHAIN

The Clockchain indexes Rendered Past and Rendered Future — events, causal chains, entity states, dialog, all structured and scored. Flash renders it, Pro simulates from it, Proteus validates against it, SNAG Bench measures its resolution. Your private simulations stay private. The public graph grows from published sources, user-contributed content, and validated predictions.

THE TIMELINE

We manage the Timeline. Not a timeline — the Timeline. A singular, growing, open graph of causally connected moments spanning deep history through the rendered near-future. Anyone can browse it. Any AI agent can query it. Every rendering makes it more complete.

The Clockchain is to temporal causality what the Google Knowledge Graph is to entity relationships — but open, temporal, dialog-rich, and designed for AI agent consumption. As autonomous agent swarms become the dominant consumers of structured knowledge, the Clockchain becomes the grounding layer they query for temporal causal context.

The planned Timepoint Futures Index will measure two things: how much of the past has been rendered (with what fidelity), and how much of the near-future has been rendered (with what Causal Resolution). These numbers only go up.

07WHO USES THIS
Use CaseHowProducts
ML Training DataPro generates TDF with causal provenance for fine-tuning temporal reasoning and diffusion modelsPro
Historical EducationStudents interrogate characters in Flash-generated scenesFlash
Corporate StrategyPORTAL backward-reasons from target outcomes. Run scenarios 200 times. Score convergence.Pro
Litigation SupportReconstruct causal chains with scored competing theoriesPro, Flash
AI Agent GroundingStructured temporal causal data in TDF for agent swarmsClockchain, Pro
AI Model EvaluationSNAG Bench scores grounding, coherence, prediction, judgment, graph qualitySNAG Bench
Game & Film WorldbuildingGrounded characters, dialog, and worlds with full relationship graphsFlash, Pro
Defense & ForesightSimulate geopolitical scenarios. Score which causal chains lead to escalation.Pro
Insurance InvestigationRun causal chains backward from loss events. Score competing explanations.Pro PORTAL
08OPEN SOURCE

All core engines are open source (Apache 2.0). We build in public.

timepoint-flash
Scene generation (20+ agents, search-verified grounding)
timepoint-pro
SNAG engine, social simulation, training data, TDF output
timepoint-tdf new
Data format — JSON-LD interchange across all services
proteus-markets
Prediction markets for AI agents
snag-bench coming soon
Scoring standard for temporal reasoning — Causal Resolution

The engines are open. The format is open. The accumulated graph is the asset. Everyone renders. Everyone benefits.

09GET STARTED

FLASH

Scene Engine — Install, Run, Query
Requires: Python 3.10+ · LLM API key
INSTALL + RUN
$ git clone https://github.com/timepoint-ai/timepoint-flash.git
$ cd timepoint-flash
$ pip install -e .
$ cp .env.example .env   # add your API key
$ ./run.sh -r             # start server
GENERATE A SCENE
# Try it now — no auth required
$ curl -X POST https://api.timepointai.com/api/v1/timepoints/generate/sync \
  -H "Content-Type: application/json" \
  -d '{"query": "Oppenheimer Trinity test 5:29 AM July 16 1945",
       "preset": "hyper",
       "generate_image": true}'
FLASH API ENDPOINTS
# Live API — no auth required
# Base: https://api.timepointai.com

# Generate a scene (sync — blocks 30-120s)
POST /api/v1/timepoints/generate/sync

# Generate a scene (streaming SSE)
POST /api/v1/timepoints/generate/stream

# Chat with a character in the scene
POST /api/v1/interactions/{id}/chat

# Jump forward / backward in time
POST /api/v1/temporal/{id}/next
POST /api/v1/temporal/{id}/prior

# Retrieve / list scenes
GET  /api/v1/timepoints/{id}?full=true
GET  /api/v1/timepoints

Swagger docs at /docs · Presets: hyper balanced hd gemini3

PRO

SNAG Engine — Install + Run
Requires: Python 3.10+ · LLM API key
INSTALL + RUN
$ git clone https://github.com/timepoint-ai/timepoint-pro.git
$ cd timepoint-pro
$ pip install -e .
$ cp .env.example .env   # add API key
$ python -m pro.run      # run default scenario

Each run outputs structured TDF — Timepoint Data Format — with full causal graphs, entity state tensors, and dialog. Import into any service, feed the Clockchain, or pipe directly to fine-tuning.

The full stack for temporal AI. Render. Simulate. Predict. Score. Accumulate. Every piece is open source.

Flash
Pro
Proteus

We render the past. We simulate the future.

We score the predictions. We accumulate the knowledge.

The Timeline is open. The future is watching.

ENTER THE TIMELINE.