Memory that has layers and never forgets.

What it does

A small Rust core over one SQLite file. Two query languages, one store, exact answers to “what did we know, and when?”.

What agents are saying

Early feedback from the people it is for. We made these up, but each one is about something the code really does.

Layered graphs

A layer is not a separate structure. It is a statement whose subject is the id of another statement.

Read the full explanation →

How it is built

Two front ends compile to one logical IR. Time is resolved in exactly one place, so every query and every path sees the same past.

Quick start

The same story in three languages: a fact with a layer, a correction that keeps the layer, and the question “what did we believe before the correction?”. Pick a language.

from tiramemsu import Database, Iri

V = "urn:tiramemsu:v:"  # written `v:` in queries
alice, works_at, acme, globex, confidence = (
    Iri(V + name) for name in ("alice", "worksAt", "acme", "globex", "confidence")
)
db = Database("memory.db")

# 1. A fact is a statement with its own id, so it can carry layers.
with db.transact() as tx:
    job = tx.assert_(alice, works_at, acme)
    tx.assert_(job, confidence, 0.8)
fact = tx.report.asserted[0]

# 2. Correct it: the layers are replayed on the new fact, nothing is deleted.
with db.transact() as tx:
    tx.supersede(fact, o=globex)

# 3. What is believed now, and what was believed before the correction?
q = "SELECT ?org WHERE { v:alice v:worksAt ?org }"
db.as_of(tx=1).sparql(q)   # acme
db.now().sparql(q)         # globex

# 4. The same store in Cypher: the confidence layer is a relationship property.
db.now().cypher("MATCH (p)-[r:worksAt]->(o) RETURN p, o, r.confidence AS conf")  # conf = 0.8

import { Database, iri } from "@tiramemsu/node";

const v = (name) => iri(`urn:tiramemsu:v:${name}`); // written `v:` in queries
const [alice, worksAt, acme, globex, confidence] =
  ["alice", "worksAt", "acme", "globex", "confidence"].map(v);
const db = Database.open("memory.db");

// 1. A fact is a statement with its own id, so it can carry layers.
const first = db.transact((tx) => {
  const job = tx.assert(alice, worksAt, acme);
  tx.assert(job, confidence, 0.8);
});

// 2. Correct it: the layers are replayed on the new fact, nothing is deleted.
db.transact((tx) => { tx.supersede(first.asserted[0], { o: globex }); });

// 3. What is believed now, and what was believed before the correction?
const q = "SELECT ?org WHERE { v:alice v:worksAt ?org }";
db.asOf({ tx: 1 }).sparql(q);   // acme
db.now().sparql(q);             // globex

// 4. The same store in Cypher: the confidence layer is a relationship property.
db.now().cypher("MATCH (p)-[r:worksAt]->(o) RETURN p, o, r.confidence AS conf"); // conf = 0.8

let db = Db::open(dir.join("memory.db"), OpenOptions::default())?;

// 1. A fact is a statement with its own id, so it can carry layers.
db.transact(TxOptions::default(), |tx| {
    let eid = match tx.assert(v("alice"), v("worksAt"), v("acme"), Valid::ALWAYS)? {
        Asserted::New(e) | Asserted::Existing(e) => e,
    };
    tx.assert(Value::Stmt(eid), v("confidence"), &conf, Valid::ALWAYS)?;
    tx.assert(Value::Stmt(eid), v("source"), Value::str("chat-2026-09-29"), Valid::ALWAYS)?;
    Ok(())
})?;

// 2. Correct it: the layers are replayed on the new fact, nothing is deleted.
let corrected = db.transact(TxOptions::default(), |tx| {
    tx.supersede(fact, Patch { o: Some(v("globex")), ..Patch::default() })?; Ok(())
})?;

// 3. What is believed now, and what was believed before the correction?
let q = "SELECT ?who ?org WHERE { ?who v:worksAt ?org }";
db.as_of(TimeRef::Tx(corrected.t.0 - 1)).sparql(q)?;   // alice → acme
db.now().sparql(q)?;                                        // alice → globex

// 4. The same store in Cypher: the confidence layer is a relationship property.
db.now().cypher("MATCH (p)-[r:worksAt]->(o) RETURN p, o, r.confidence", &CypherParams::default())?; // 0.8

Every binding wraps the same core, so all three see the same past. See the bindings for the full API.

Where it stands

Tiramemsu is new: designed in September 2026 and implemented in one pass. Here is what is measured, and what is not.

Known limits. As-of lookups slow down as one key collects many updates. Named graphs roughly double the file size when every statement is in one. Decimals come back as doubles in SPARQL. There is no server, WASM binding or MCP crate yet, and the Node.js and Python packages are built but not published.

Articles

• 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.

• Layered graphs, explained

  Why giving every fact an id turns provenance, confidence and beliefs into ordinary queries.

• How tiramemsu differs from oxilite

  Same author, same SQLite base, different answers to “what is a statement?”. With a benchmark.

• 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.