TemporalStore.AI GitHub

Open source · Rust · Apache-2.0

LLM infrastructure for temporal memory and state

TemporalStore is a perfect fit for temporal storage plus serving problems, including context management. It gives teams a Rust-native foundation for building any LLM context layer on top of it, while also serving temporal features, risk-control state, replay, memory-first tiering, extreme high-concurrency reads and writes, and compute/storage separation for disaggregated deployments in one durable engine.

Why it wins

Why agent context needs a temporal serving and storage engine.

An AI agent is only as good as the context it is given. The usual answer — stitch a vector database to a cache to a feature store to a queue, then replay whole histories into every prompt — is expensive to run, hard to keep in sync, and impossible to audit. TemporalStore treats context management as a serving plus dedicated storage problem: one temporal engine remembers what happened, when, where, and why across sessions, agents, devices, teams, and tools, then serves the model a compact, source-backed ContextPack instead of a transcript.

The payoff is concrete. Managed, de-duplicated packs send only fresh, relevant evidence, so you get Fewer tokens at equal answer quality — often a large reduction in prompt tokens. Time-valid memory with stale-context blocking and replayable citations means Better answers and less hallucination. And because retrieval is bounded temporal reads over a memory-first, multi-layer architecture, serving latency stays extremely low even across millions of entities. Hot context stays in memory, warm state moves through PMem and SSD, and cold replay history lands in shared storage. See benchmarks.

Beyond speed and quality, TemporalStore is one service instead of four: memory, retrieval, summaries, safety counters, and replay live in a single store. Every decision is replayable and auditable — reconstruct the exact context behind any answer for debugging, evaluation, or compliance. And it is open source: self-host on premise, run in your cloud, or scale the same engine to disaggregated shared storage and five-nines when you need it.

Tokens

Fewer prompt tokens

TemporalStore turns cross-session, cross-agent, and cross-device short-term plus long-term team memory into fresh, source-backed ContextPacks instead of repeated transcript noise.

Quality

Better answer quality

Time windows, supersession, stale-context blocking, and replayable citations keep the model grounded in what is current, permitted, and actually relevant.

Storage

Memory-first temporal storage

Context is stored as model-aware temporal state, not opaque chunks. Hot state is served from memory first, then automatically moves across PMem, SSD, and shared storage as it cools.

Scale

Compute/storage separation

Local, Raft, and shared-store modes let deployments move from a self-hosted node to disaggregated storage where stateless datanodes scale independently.

Performance

Extreme serving latency

Memory indexes, PMem/SSD cache fill, WAL-first durability, and append-structured blocks are built for extreme high-concurrency writes and reads across large agent workloads with simultaneous ingest, retrieval, and replay.

Operations

Less maintenance

One engine replaces a patchwork of vector DB, cache, feature store, queue, summarizer, replay store, and repair jobs, while remaining open source and self-hostable.

Tech & infrastructure

Real serving infrastructure under the LLM layer.

TemporalStore is not a prompt trick or a sidecar vector index. It is a temporal serving and storage engine with routing, WAL durability, model-aware datanodes, a memory-first multi-layer cache, and automatic hot-to-cold context movement across memory, PMem, SSD, and shared storage.

Clients
AI agents & online servicescontext writes · retrieval reads · replay jobs
↓  serve context as data  ↓
Serving core — open source
Proxyrouting, batching, backpressure
Metaserverplacement, leases, shard map
DatanodesWAL, model executors, indexes
Open-source runtime libraries
MatrixCacheopen-source multi-layer cache
MatrixRaftRust Raft protocol for replicated WAL and failover
↓  automatic hot-to-cold data movement  ↓
Temporal storage tiers
Memoryhot context, live index
PMemnear-memory warm state
SSDwarm blocks and snapshots
Shared storagecold replay history
Enterprise scale-out backends

This is the compact main-page view. The deep dive covers storage files, page indexes, cache admission, Raft vs shared-store replication, sync vs async durability, and local/distributed deployment. Open the Tech & Infra deep dive →

Open source

Apache-2.0 and self-hostable.

Run the Apache-2.0 stack yourself with TemporalStore, MatrixCache, and MatrixRaft. Bring your own OSS models, then add enterprise object/KV/DB backends only when you need disaggregated, five-nines deployments.