Articles
Start here
The ideas everything else builds on.
Layered graphs, explained
Why giving every fact an id turns provenance, confidence and beliefs into ordinary queries, and what it costs.
Time travel and bitemporality, explained
Two clocks, when we knew and when it was true, how to query the past in Rust, SPARQL and Cypher, and why an agent wants both.
From datoms to graphs
For Datomic users: the same EAV setup in Datalog, query by query, then what an id per fact and a second clock add. Edge properties, provenance per fact, temporal joins, constraints at commit, and what Datomic has that this does not. Every query is a test.
How tiramemsu is built
One diagram of the layers, from the query front ends down to the one SQLite file, and the four ways to use it.
Questions only layers can answer
Evidence through time, impact analysis, who wrote it and why it was forgotten, contradictions, cited answers and portable facts: tested recipes.
Recall
Finding things by words and by meaning, in any moment.
Words, meaning and evidence: hybrid recall
Text and vector recall fused by reciprocal rank, ties broken by evidence, expansion to layers and subject facts with via, recall in the past, the same call in Rust, Python, SPARQL, Cypher and MCP, and measured numbers.
Vector memory that remembers when
Recall by meaning in a memory that travels in time: why top-k-then-filter loses answers under as_of and valid_at, exact search over the visible statements, hybrid recall with text, and honest limits.
Vector cookbook: indexes, embeddings and search in every language
Copyable samples: create and drop vector indexes, add embeddings and search them from Cypher, SPARQL, Rust, Python, Node.js and MCP, search in the past, backfill, and the rules and errors.
Recall, review, recheck
How an agent’s memory finds things by words, sees where sources disagree, and knows when a saved answer has gone stale.
Agents and use cases
Putting the memory to work.
Give your agent a memory over MCP
Setting up tiramemsu-mcp in Claude Code and Claude Desktop: the tools, read-only mode, budgets, provenance coverage and a sample session.
Causal-temporal event graphs on Tiramemsu
Agent traces that say what caused what: the CTEG model, why it matters for multi-agent workflows, and how statement ids and two clocks check and query it in SPARQL, on the real trace of the agent that wrote the article.
Journeys that respect time
Time-respecting paths in SPARQL and Cypher, earliest arrival, and how a query says whether its paths were complete.
Ten features for agents
Speculation, schemas, review, recheck, bundles and more: each with what it is, why an agent wants it, examples in Python, Node.js and Rust, and its limits.
Reasoning
Rules over a memory with two clocks. A design preview.
Validators that ask “what if”
A hands-on tour of ELPI: a question over memory, hypothetical answers with
=>that write nothing, policies passed as predicates,pifor any member, a validator that refuses a bad write, and conclusions that stay grounded. Every example is a test.λProlog in a bitemporal memory
Adding ELPI as a third reasoning language: lean-elpi reading the store through callbacks, typed terms, support the program states, valid time by intersection, validators checked at commit, and three things the tests found.
ELPI in Tiramemsu: a guide
Builtins, terms, time, constraints enforced at commit, stored programs with includes, materialization and goal calls from SPARQL and Cypher, with every surface, the errors and the limits.
Reasoning with N3 in Tiramemsu: a mini book
Ten short chapters: N3 in fifteen minutes, your memory as N3, reasoning as of any transaction, valid time that never combines facts from different moments, rule sets with history, materialized conclusions that fall with their premises and rules, seven recipes, a reference, and both clocks exported as RDF 1.2.
Structure
Metagraphs, statement graphs and how they relate.
Metagraphs from one row shape
Edges that are vertices, vertices and edges that hold subgraphs, nesting, n-ary edges, fold and unfold, all as statements with two clocks.
Statement graphs and tiramemsu
The model behind Amazon Neptune's OneGraph and tiramemsu share one idea, statement ids. Why storing each statement as one record matters.
Taking memory out whole
tm export --format sg-nt12: every statement with its id and both clocks as RDF 1.2 reification, asserting what is live in the view you choose. What is left out, and why valid time istm:validFromMs.An export with a proof
LeanRDF proves the format's decoder exact in Lean, makes the paper's criterion and kernel executable, and checks tiramemsu's Rust exporter byte for byte on every build.
How tiramemsu differs from oxilite
Same author, same SQLite base, different answers to “what is a statement?”, with a benchmark and a list of what each does not do.
Engines and performance
Storage engines, joins, budgets and benchmarks.
Two engines, one memory
SQLite or redb, chosen when you create the file: one logical database in both, why we added a second engine, and what the benchmark against SQLite and Oxigraph says about each, losses included.
Worst-case-optimal joins on a key-value store
How the native runner joins SPARQL and Cypher patterns over redb, what it borrows from RDF-3X, Kùzu and Umbra, and the performance bugs the benchmark found in it.
Benchmarks: SQLite, redb and Oxigraph
Every number of the backend benchmark at 10⁵ and 10⁶ statements, as tables: joins, cycles, lookups in time views, Cypher, paths, concurrent readers, writes and size, with the fastest engine of each row marked.
Why the new engine was not faster, and what made it faster
Profiling redb against SQLite: values decoded a byte at a time, allocations per row, a join order that started at the wrong end and filters that never reached their pattern. F1 4× and the Cypher two-hop 124× faster.
Datalog over time: rules, constraints and derived beliefs
DatalogMTL and Allen relations over valid-time interval sets, stratified negation, constraints enforced at commit and materialized conclusions that fall with their premises, compared with N3 and measured against it, losses included.
Putting an N3 reasoner inside a bitemporal memory
How eyeron runs over a store with two clocks: statements as IRIs, a segment sweep for valid time, a pinned clock, rule sets as versioned statements, conclusions that fall with their premises, the conformance tests, and the dependency problem that blocks publishing.
Building a Datalog engine for a bitemporal store
The engineering account: why not an embedded engine, time inside the join, four bugs the tests found, constraints that cost what the write costs, and the benchmark numbers including two gates that were missed.
Datalog in Tiramemsu: a guide
The language, the temporal operators, constraints, stored programs, materialization and goal calls in one reference, with the errors and the limits.
Bounded queries and bulk loads
Budgets, cancellation and result limits, bulk import sessions, and a join operator for cyclic patterns with a small triangle benchmark.
Research
Plain-language companions to the papers.
One record, three questions
The three papers in one page with one running example: does memory stay grounded, can structure be read back, and what can leave the store intact.
Memory that stays grounded
A plain-language companion to the paper: one operator explains the cascade, time travel, valid-time slices and corrections, and why metagraphs get two clocks for free.
Cheap to write, careful to read
A plain-language companion to the metagraph paper: exact images and why each condition is needed, annotations that outlive their bearers, executable metapaths, and what depth costs.
What leaves the store intact
A plain-language companion to the export paper: closed and acyclic sets, the export kernel, why history exports when snapshots do not, both clocks in RDF-star, and RDF 1.2 and property graphs.