NORTHTEKDevs/genome

**Open memory for AI agents. Same answer accuracy as Mem0 - but ~1,000× cheaper to store, runs fully offline, and keeps an auditable record.**
**Papers:** Do Agents Need an LLM to Remember? (the core evaluation, 2026) and What Does Each Memory Feature Buy? (a measured audit of all five optional features, wins and failures alike, 2026). PDFs in papers/; result tables in benchmarks/AUDIT-RESULTS.md.
Most agent-memory tools (like Mem0) call an LLM on **every message** to decide what to
remember. That's the slow, expensive part - and GENOME's bet is that you don't need it.
GENOME just embeds each message locally: no LLM, no API, no network in the write path.
Benchmarked honestly on public datasets (LoCoMo, LongMemEval), GENOME **answers just as
accurately as Mem0** - while storing memories for a tiny fraction of the cost and running
completely offline.
> **Honest up front:** on answer accuracy, GENOME *ties* Mem0 - we do **not** claim to beat
> it there (six independent benchmark configurations confirm parity, none significant in
> either direction). The advantage is cost, speed, offline operation, and a
> temporal/auditable record Mem0 can't produce.
See it work
Every frame is real output from examples/demo_timeline.py,
captured by tools/render_demo_gif.py. Run it yourself,
no API key required:
The interesting part is step 3. The same question gets three different correct answers
depending on *when* you ask about, because the store keeps when each fact became true
rather than overwriting it:
| Question | Answer |
|---|---|
| What was Priya's city in May 2023? | Boston [Mar 2023 - Jan 2024] |
| What was Priya's city in March 2024? | Seattle [Jan 2024 - Feb 2025] |
| What is Priya's city now? | Austin [Feb 2025 - present] |
The "thinking about maybe moving to Denver, nothing decided" turn is stored but never
becomes an answer: it is a plan, not a durable fact.
How it works
The write path is deliberately dumb and cheap. All the intelligence happens at read time,
when there is a query to focus it.
Write: embed locally, store. About 10 ms, zero LLM calls, zero network calls. The
embedding is deterministic -- the same text always yields the same vector, with no
sampled extraction step deciding what matters -- so what gets stored is a function
of the input, and replaying a journal reproduces that store exactly. (Ids and
timestamps are stamped per write, so two independent ingests of the same
conversation agree on content and vectors, not on record ids.)
Read: exact cosine search within the tenant's scope (no ANN index to build or update),
with an optional local cross-encoder reranker.
Bi-temporal layer (opt-in): records each fact at its **domain time**, the moment it became
true in the world, not the moment it was ingested. That is what makes point-in-time
questions answerable even when facts arrive out of order.
Why the record can be re-derived
A record that cannot be re-derived is difficult to audit. That property, not accuracy, is
the actual argument for this design.
Don't believe it? Prove it yourself
The **cost, speed, and offline** claims need no API key - measure them on *your* machine in 60 seconds:
The **first** run downloads the local embedding model (~90 MB, one time) before printing
anything, so expect 30-120 seconds of apparent silence on a cold machine. Every run after
that is instant.
It writes memories with your **outbound network physically blocked** and prints a live
pass/fail receipt - 0 network calls, 0 LLM calls, single-digit-ms writes, retrieval that works:
That receipt covers the cost/speed/offline story only. The **accuracy-parity with Mem0** claim
is a separate, larger check that needs an LLM key - reproduce it head-to-head on the same
questions with your own key via python benchmarks/head_to_head.py (one OpenRouter key works;
see benchmarks/RESULTS.md for the n=90 / n=205 runs, the paired
significance tests, and the published nulls). The full test suite runs in public CI (badge
above). The pitch isn't "trust me" - it's "run it."