# Aru open-sourced lossless-memory, an AI memory that refuses to summarize > Source: > Published: 2026-09-21 12:54:50+00:00 # Aru open-sourced lossless-memory, an AI memory that refuses to summarize **The local Python project stores every conversation line with a timestamp, turning one creator's years of assistant frustration into code.** By [RuntimeWire Staff](https://runtimewire.com/author/runtimewire-staff) ยท Published Primary source: [GitHub](https://github.com/aru-labs/lossless-memory) ## Why it matters Aru treats raw conversation history as the durable asset and summaries as disposable indexes. That design offers builders a concrete alternative to letting another model decide which parts of a user's past survive. A creator who writes under the name [Aru](https://note.com/aru_log?ref=runtimewire) published the first version of [lossless-memory](https://github.com/aru-labs/lossless-memory?ref=runtimewire) on September 4th, building a local memory layer that preserves every line of an AI conversation instead of asking another model to decide what deserves to survive. The project is the technical result of a personal experiment that began in December 2025. Aru had spent years talking with AI assistants and repeatedly watched details disappear when conversations crossed session and context limits. A predecessor ran daily from January 2026, while the current implementation has been used by Aru since July, with raw logs extending back to June. Aru's frustration was specific. Summaries could retain names, decisions, and broad themes while losing chronology, tone, jokes, and the words that made an exchange recognizable. In a [Japanese-language account of the project's origins](https://note.com/aru_log/n/nfc2e964cf108?hl=en&ref=runtimewire), Aru described building an earlier compression tool called ENIGMA. The compressed records transferred factual knowledge, but details were corrupted, timelines moved, and punchlines vanished. That failure led to the rule at the center of lossless-memory: keep the source conversation intact and build replaceable indexes around it. "The parts that the AI thinks are noise are important to me," Aru said in the account. ### Time comes before similarity Each conversation turn becomes a seven-field record containing a timestamp, actor, role, content type, text, model identifier, and session identifier. The records are appended to daily JSONL files, which remain the source of truth. Every index can be deleted and rebuilt without altering the underlying conversation. The retrieval system uses SQLite FTS5 for exact text search and sqlite-vec for semantic search. Aru puts semantic retrieval last in the sequence, rather than treating an embedding's estimate of similarity as the primary definition of memory. The project's "Temporal Backbone" parses a date or time reference before ranking text. A request about a decision made last Tuesday night first restricts the search to that period, then looks for matching words and returns the original lines in chronological order. The approach is designed to prevent a semantically similar exchange from another week from outranking the conversation the user actually requested. A separate component called LLL tracks the conversation's current topic. These short, timestamped markers are inserted into the model's context on every turn, helping the assistant continue after context compaction or a session change. Aru gives the human control over those markers: the AI reads them, while the person sets priorities and marks topics complete. That division keeps the model from becoming the sole editor of its own history. Lossless-memory's approach differs from commercial and open-source memory systems built around extracting useful facts or assembling compact context. [Mem0](https://docs.mem0.ai/features/contextual-add?ref=runtimewire), for example, uses language models to identify information worth storing and vector search to retrieve it. [Zep](https://help.getzep.com/graph-overview?ref=runtimewire) builds temporal knowledge graphs from entities, relationships, facts, and raw episodes. [Letta](https://docs.letta.com/tutorials/attaching-detaching-blocks/?ref=runtimewire) gives agents persistent, editable memory blocks that can be attached to their context. Aru is making a narrower bet. The raw record remains authoritative, time structures recall, and any compact representation serves as an index rather than a replacement. That costs storage and moves more responsibility onto retrieval, but it avoids turning a model-generated summary into the only surviving account of an exchange. ### A personal system, with personal-scale evidence The published measurements come from Aru's own installation. According to the [repository's operational measurements](https://github.com/aru-labs/lossless-memory?ref=runtimewire), an exact-search index rebuild fell from 40 seconds to 1.24 seconds after a redesign. The vector store shrank from 2.54 GB to 337 MB after Aru removed stale and unrelated records. The failure behind that reduction is documented in the project's [lessons file](https://github.com/aru-labs/lossless-memory/blob/main/docs/lessons.md?ref=runtimewire). An ingestion step rewrote its output, while the incremental indexer continued appending records as though the file had only grown. Old rows accumulated, along with roughly 750,000 lines of unrelated library data. Semantic fallback eventually began retrieving foreign-language dictionary entries and license text as memories. Aru fixed the indexer to detect rewritten and deleted sources, then retained the failed measurements in the documentation. That detail matters because lossless storage alone does not produce trustworthy recall. An untouched transcript can still sit beneath a polluted index that returns the wrong evidence. The project remains deliberately constrained. It is designed for one person, one assistant, and one machine, with no server or cloud component. Its most-tested ingestion path uses Claude Code JSONL history. A generic importer accepts timestamp, role, and text fields, but the broader path has less operating history. Relative time parsing is Japanese-first; English queries currently need absolute dates. There are also no comparative benchmarks. The repository describes the figures as operational measurements, and they should be read that way. Lossless-memory has demonstrated daily use in one installation, rather than performance across users, workloads, or competing memory frameworks. Keeping complete transcripts locally also leaves backup, encryption, retention, and device access decisions with the person running it. ### The assistant helped build its own memory The [initial release commit](https://github.com/aru-labs/lossless-memory/commit/77989f7b2cdd6fe166b9af1bcaac8b1b3d9596a6?ref=runtimewire) added 4,791 lines across code, tests, examples, and English and Japanese documentation. Its commit metadata credits [Anthropic's Claude Fable 5.1](https://www.anthropic.com/claude/fable?ref=runtimewire) through a Claude Code session, indicating that Aru used an AI coding collaborator while implementing the system. The repository also credits Cece, the personal AI whose conversations the system stores, as a co-designer and co-writer. Aru describes the longer-term aim as a locally operated companion for people who live alone, running on hardware they own. Lossless-memory is one component of that larger project. That origin explains why the implementation values fidelity over the usual pressure to compress everything into the smallest possible context. Aru is building for continuity with one assistant, rather than an API serving millions of unrelated sessions. The project's small scale limits what its results prove, but it also gives the design a coherent requirement that larger memory platforms frequently soften: the user's record cannot be discarded merely because a model considers part of it unimportant.