The standard workaround for stateless LLM agents is brute-force: concatenate every prior turn into the prompt and hope the model finds what it needs. That approach degrades in three directions simultaneously: token cost grows linearly with history length, latency follows, and accuracy drops as irrelevant turns accumulate and crowd out the signal. A better long-term memory layer is the obvious fix, yet most published memory systems trade accuracy for speed or cost rather than improving on both. This paper introduces Engram, an open-source bi-temporal memory engine that claims to beat the full-context baseline on accuracy while using roughly eight times fewer tokens. The preprint is available at arXiv:2606.09900.
What Engram Actually Does
The system is built around a dual-process architecture that separates write latency from write quality. On the fast path, raw episodes (conversation turns, events) are appended losslessly without any LLM call on the critical path, keeping ingestion cheap. An asynchronous consolidation process then extracts atomic (subject, predicate, object) facts from those episodes, builds a knowledge graph, and resolves contradictions, again without requiring an LLM call per fact.
The genuinely interesting design choice is the bi-temporal data model. Every fact carries two independent time axes: valid time (when the claim is true in the world) and transaction time (when the system learned it). When a contradicting fact arrives, the old fact is invalidated rather than deleted. Its invalid_at timestamp is set, a supersession pointer is added, and provenance is preserved. This makes point-in-time queries intrinsic to the data model rather than a post-hoc filter. Ask where someone works as of six months ago and the system resolves against the fact that was valid then; ask the same question today and it resolves against the current fact. For benchmarks that test temporal reasoning and knowledge updates, this is not a minor implementation detail but a structural requirement.
The read path is where the accuracy gains are argued to originate. Retrieval fuses four signals: dense vector similarity, lexical (BM25-style) matching, graph traversal, and a recency/salience score that decays over time. A point-in-time filter is applied before assembly, and the final context is compact and provenance-tagged rather than a raw dump of retrieved chunks. The authors describe this as the load-bearing component: a facts-only retrieval path loses recall on questions requiring verbatim detail, while the hybrid path (facts plus raw episode chunks) recovers it.
Results and the Reproducibility Argument
On the full 500-question LongMemEval S benchmark, Engram's lean configuration scores 83.6% against a full-context baseline of 73.2%, a 10.4-point gap that is statistically significant (McNemar exact p < 10^-6). The retrieved context averages approximately 9,600 tokens versus roughly 79,000 tokens for the full-history condition. Zero questions errored under either system.
The paper's second contribution is arguably as important as the system itself. Memory benchmark numbers in the literature are, by the authors' account, essentially incomparable across papers. The same system can appear at 58%, 66%, or 92% depending on which ingestion pipeline, answer prompt, and judge were used. The authors identify three specific measurement-integrity pitfalls: history truncation that leaks information into the retrieved context, home-grown judges that diverge from the official category-specific grader, and full-history baselines that are omitted entirely. Engram ships with a neutral, in-repo evaluation harness, the official judge baked in, the full-context baseline included in every table, and raw per-question logs published alongside a command to reproduce every reported number.
Limitations Worth Taking Seriously
The authors are unusually candid about scope, which makes the paper more credible but also surfaces real constraints.
- Single benchmark, single answerer. All headline numbers come from LongMemEval S with one answerer model (doubao-seed-2.0-pro). Whether the gains hold with a smaller open-weight model or on LOCOMO is stated as immediate future work, not demonstrated here.
- Single run, no controlled ablation. Run-to-run variance from answerer stochasticity is unquantified. The comparison between the facts-only and hybrid read paths is reported as an observation rather than a controlled full-set ablation, which limits how confidently one can attribute the accuracy gain specifically to the hybrid retrieval design.
- Small samples mislead badly. The authors note that an 18-item development slice once read 83% when the full-set truth was approximately 58%. This is a useful warning for the field generally: memory benchmark results on small held-out slices are unreliable, and the variance can easily exceed the effect sizes being claimed.
- Open categories. Multi-session aggregation and preference questions are identified as the remaining weak spots, with the multi-hop query planner and bi-temporal conflict resolution as the expected levers. Neither is fully evaluated here.
The model stack is also worth noting for reproducibility purposes. The fact extractor uses doubao-seed-1.6-flash and the answerer uses doubao-seed-2.0-pro, both Bytedance models accessed via API. The embedder (BAAI/bge-small-en-v1.5) runs locally. The harness is designed to swap any OpenAI-compatible endpoint via LiteLLM, so the infrastructure is portable, but reproducing the exact numbers requires access to the same model versions.
Broader Implications
The framing here matters. Most prior memory systems position themselves as cost or latency optimisations relative to full-context, accepting an accuracy penalty as the price of efficiency. Engram's claim is different: that a well-structured, selectively retrieved context can be more accurate than the full history, not just cheaper. If that holds across multiple benchmarks and model families, it reframes long-term memory from infrastructure overhead into a quality mechanism.
The bi-temporal data model is the most transferable idea in the paper. Treating valid time and transaction time as first-class schema properties, rather than metadata appended as an afterthought, is a pattern with clear precedent in database systems (notably the SQL:2011 temporal tables standard) but rarely applied rigorously in LLM memory architectures. The invalidation-without-deletion invariant is particularly well-suited to the class of questions that current benchmarks test hardest: tracking belief updates, resolving contradictions, and answering queries anchored to a specific point in time.
The reproducibility contribution is timely. The field is accumulating memory system papers faster than it is accumulating trustworthy comparisons between them. A neutral harness with a fixed judge, a committed full-context baseline, and published logs does not solve the problem across the literature, but it sets a concrete standard that other groups can adopt or argue against. Whether that standard propagates depends on whether reviewers start requiring it.
Read the full paper at https://arxiv.org/abs/2606.09900.