A Personal AI Memory That Keeps Everything, Word for Word

aru-labs has published lossless-memory, a local file-based memory layer for personal AI that stores complete conversation logs with no summarization anywhere in the pipeline. aru-labs/lossless-memory

The scope is narrow by design. The system is built for one person and one AI running on one machine, with no server and no cloud.

Storage uses two parts that work together. Appendable JSONL logs, which are plain text files where each line is a separate record, are paired with SQLite, a lightweight database stored as a single file. It uses FTS5 for exact word search and sqlite-vec for semantic search, which finds passages by meaning rather than exact wording. That keeps both kinds of recall inside the same local database file.

Ingest follows the same pattern every time. Each conversation turn becomes a fixed seven-field record with ts, actor, role, type, text, model and session, and is added to a JSONL file for that day. Every record carries a timestamp. The timestamp is not side detail. It is the ordering principle for storage and retrieval.

Indexes sit on that time axis. The project calls this structure the Temporal Backbone. Alongside it is LLL, a current-position index made to be added to the model's context on every turn. The raw log remains the authoritative source, while the indexes provide access paths into it.

The system has run daily since July 2026 as the memory for a single user's AI assistant, with raw logs reaching back to June 2026. aru-labs/lossless-memory

The broader context here is the trade between fidelity and convenience in agent memory. Most production memory systems use summarization, compaction or decay. Those methods limit storage growth, control embedding costs and keep the context budget predictable. Lossless-memory takes the opposite approach. It keeps every line verbatim and leaves all selection until retrieval time.

In my view, the core technical bet is that timestamped exact search plus semantic search over complete history can stay precise enough to be useful without a middle layer that rewrites what happened.

In my view, the no-summarization rule also changes how the system fails in ways practitioners will recognize. Summaries drift. They mix up speakers, flatten sequence and quietly drop edge cases that later matter, like meeting minutes that lose who said what. Raw retention avoids that class of error. It replaces it with a different burden. Retrieval ranking must work harder, and the per-turn injection of LLL state must stay small enough for routine inference while still pointing usefully into a corpus that grows every day. Fidelity is preserved. Relevance must be earned on each query.

Looking at what this means for builders, the single-machine limit does much of the design work. File-local JSONL plus SQLite removes sync, multi-tenancy and remote index operations from the design. Provenance stays simple. Each turn is attributable by session, actor, role and model, ordered by ts. The cost is clear as well. One principal, one agent, one host does not handle sharing, migration or concurrent writers. For personal assistants where continuity matters more than collaboration, that may be an acceptable exchange. Time becomes the primary key, with lexical and vector indexes as secondary paths, and long-lived personal context stays under direct local control rather than inside a remote service that decides what is worth keeping.