Lossless-Memory Keeps Every Line: Local AI Recall Without Summarization

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

The scope is deliberately narrow. The system is designed for one person and one AI running on one machine, with no server and no cloud. Persistence pairs appendable JSONL logs with SQLite, using FTS5 for exact search and sqlite-vec for semantic search. That combination keeps lexical recall and vector recall inside the same local database file.

Ingest is uniform. Every conversation turn becomes a fixed seven-field record with ts, actor, role, type, text, model and session. Records are appended to a per-day JSONL file. Every record carries a timestamp, and the timestamp is not metadata on the side. It is the ordering principle for storage and retrieval.

Indexes sit on top of that time axis. The project calls this structure the Temporal Backbone. Alongside it sits a current-position index called LLL, designed to be injected into model context on every turn. The raw log remains authoritative, while the indexes provide access paths into it.

The implementation 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 stacks introduce summarization, compaction or decay. Those techniques bound storage growth, control embedding costs and keep the context budget predictable. Lossless-memory takes the opposite position. It preserves every line verbatim and pushes all selectivity into 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 an intermediate abstraction layer that rewrites what happened.

In my view, the no-summarization rule also changes failure modes in ways practitioners will recognize. Summaries drift. They conflate speakers, collapse sequence and silently drop edge cases that later turn out to matter. Raw retention avoids that class of error. It replaces it with a different burden. Retrieval ranking must do more work, and per-turn injection of the LLL state must stay compact enough for routine inference while still pointing effectively 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 constraint is load-bearing. 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 address 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.