Field notes

The same 22 real conversations behind our 98.1% number went through Mem0 and Graphiti — the open-source engine inside Zep — running the identical model Lethe uses. One blind judge graded every stored claim from every system, never knowing whose it was.

Lethe: 211 claims, 100% grounded, the only system that cites the exact line each claim came from, and the only one that stored something for every conversation. Mem0: 98.6% grounded — and 8.6× faster than us, and more grounded than the reasoning tier we actually ship (93.6%, dragged down by a schema bug our own 2026-08-20 run already flagged). Zep: 82.8% grounded on three times the volume — hypotheticals stored as history, but also real signal we missed; even discarding every fabricated claim it banked ~2.5× more grounded material than we did.

The wins argue for the quote gate. The losses are a speed gap, an unfixed bug with a price tag, and a recall ceiling — all now in the published record, because a scoreboard that only shows our row isn’t a scoreboard. We also audited every failed verdict by hand and found 11 the judge got wrong — all in Zep’s column, all corrected upward in the record.

Same day, we tested whether the volume gap was self-imposed: our prompt says “prefer fewer observations,” so we relaxed only that line and re-ran everything. 62% more claims, precision unchanged, latency identical — the cap was buying nothing. A third blind pass then asked whether stored claims are actually useful, and handed out one more loss: Mem0’s memory is the cleanest tested (91.6% useful-and-true, above the tier we shipped that morning), while over half of Zep’s volume turned out to be world facts and fragments.

By evening the fixes had shipped and the benchmark ran again: the shipped prompt now grounds at 98.8% — past Mem0 — at double the volume, and a three-lens union arm stored 1,236 claims, 1.9× Zep’s entire count, still 98.5% grounded. After paraphrase dedup, one frozen rule applied to every system (we lose 21% of that count, Zep loses 36% of theirs), it still holds 3.2× Zep in claims that are distinct, true, and worth keeping. A final round of fixes pushed precision to its best measured — 99.1% grounded, 99.3% verbatim — and settled the usefulness question honestly: Mem0’s 91.6% rate is the rate of a narrow net, so the number we hold ourselves to is useful-and-true claims per conversation: 13.7 to their 8.9. Mem0 remains 20× faster, and dedups perfectly. Every number, morning and evening, is in the doc.

When you type “the review is on Tuesday”, most systems store the word Tuesday. Six days later that word is worse than useless — it points at the wrong day.

Lethe now resolves every relative date against the moment you said it, in your own timezone — and deadlines come back to find you: if something you mentioned is overdue, due today, or due tomorrow, it pops while you have Lethe open, on your machine’s own clock. Once per day per item, and only for dates that actually resolved — never for things you merely said recently.

We built a baseline of 12 working patterns a careful reader finds across 38 real conversations, then blind-matched what Lethe extracted against it. Today’s product surfaces 5 of the 12 — 41.7%.

Every single miss was a cross-conversation pattern: things nobody ever states in one chat, like “you work in intense bursts, then go quiet for days.” That one isn’t in any sentence — it only exists in the timestamps. In a test harness, adding timing arithmetic and a chunked synthesis pass over stored claims reached 11 of 12 (91.7%). That harness is not the product yet — when it ships, this note gets a successor with the shipped number.

We wanted to claim “with Lethe your chats use fewer tokens, because you stop re-explaining.” So we measured it: our context injection costs ~543 tokens, while the median conversation opening it replaces is 29 tokens. Only 5 of 44 real conversations broke even.

So we don’t make that claim. What context buys you is not fewer tokens — it’s not having to perform the introduction again, and answers that start from your actual situation instead of a guess. We’d rather tell you what the measurement said than what the pitch wanted.

The most useful thing Lethe knows about how you work — “you work in bursts, then go quiet for days” — appears in no sentence you ever typed. It lives in the gaps between sessions, so it’s computed, not inferred: plain arithmetic over timestamps, with thresholds it must clear before it may speak. Every rhythm fact shows its own numbers, so you can check the claim against your own calendar.

268 claims extracted from 22 real conversations across ChatGPT, DeepSeek and Grok exports. Two separate checks, because they fail differently: does the cited quote literally appear in the source (code, no model — 95.5% verbatim), and does that quote actually support the claim (blind-judged — 98.1% grounded, 5 claims failed).

Worth publishing too: our first run reported 68%. The engine wasn’t wrong — the judge was reading truncated sources and calling real quotes fabricated. A benchmark that can’t be wrong can’t be trusted, so the broken run is part of the record.

Lethe pseudonymizes names before anything is stored — your people are “Person 1, Person 2…” in the cloud, and their real names live only on your device. A numbering bug quietly assigned hundreds of distinct people to the same record: 418 humans, one label. That’s a correctness failure and a privacy failure at once — merged people means merged facts.

Every path that stores a person now runs through one stable ledger, covered by tests. We’re telling you because the pseudonym system only deserves trust if its failures are disclosed like this one.

We replaced the marketing page with a playable ninety seconds: an egg, a letter, and your files riding to the AI you already use. People don’t read positioning; they remember what they did. Finishing the journey is the only thing that dismisses it — closing it early brings it back next visit.

A QR hand-off for your context — scan a code on any device and your memory rides along. We liked it enough to design it. Then we asked what it would add once the gateway exists: nothing but a second door to maintain, and stale codes to re-mint forever.

So it died in design review instead of in your app. Killing a feature you like is a feature: every door we don’t build is one that can’t be left unlocked.

Our public demo sometimes returned less than it found. The cause was a “safety” cap on model output that nobody had ever measured a need for — a speculative limit, quietly truncating real work.

Two rules came out of it: no caps we haven’t justified with a measurement, and no silent failure paths — anything that drops work must log that it did. On a demo, a slow correct answer beats a fast empty one, so timeouts are pinned generous and the work is never trimmed to look quick.

One of our demo’s prompt rules was written as a pure prohibition. Watching real runs, the model — told only what not to do — improvised in the gap, and in one run guessed a user’s gender it had no business guessing.

The rule was rewritten to say what to do, and that’s house style now: every rule states the wanted behaviour, not just the banned one. A model with no positive instruction doesn’t stop — it guesses.

Anyone can store your chats. The bet we committed to: what matters is an identity you own that travels — readable by any AI you use, sliced per app (your work context to your coding tool, none of your personal life), revocable any time, exportable whole.

Memory is the storage; identity is the product. Every feature since this date serves that line.

“Who did I discuss the rebrand with?” needs more than matching words — it needs walking from a project to its people to what was said. Graph traversal and richer record shapes shipped: questions now travel relationships instead of just text.

Real people name the same fact differently across months. Synonym topics now collapse into one canonical attribute with the history preserved underneath — so “what’s the deadline?” finds the answer whether you called it a deadline, a due date, or the ship date. Every placement stays explainable: click any value and see the exact line it came from.

Users kept asking why their own screen said “Person 3”. Fixed the right way round: your device holds the name map and rehydrates real names locally at display time; storage and sync still only ever see the pseudonym. Also from the same feedback batch: merging duplicate people, and a panel showing every confirmation Lethe has asked.

Our first nesting default assumed companies contain projects — org-chart thinking. Real use runs the other way: in a job hunt or a client contract, the company is a participant inside your project. Your job search contains Acme; Acme doesn’t contain your life.

A small flip, but defaults are destiny in a memory system — the wrong one quietly misfiles months of context.

Internally, every memory has a type name and a confidence score. We decided the interface never shows them: you get plain language — “seen 4 times”, “from timing” — not schema words and decimals.

But the number exists, and if you ask “how sure are you?” you get it exactly. Plain by default, precise on demand — respect in both directions.

Free while in beta, no card, no plan-picker theatre. Charging comes back when the product has proven it deserves it — with usage, not promises. The landing page was rewritten the same day to say what Lethe actually is: one identity, every AI you use.

“Prefers async over calls”, “vegetarian”, “mornings are deep work” — Lethe now keeps life preferences as their own layer, each one graded: did you assert it, or did we derive it from patterns? Derived ones say so, and sharing is per-domain — your food preferences never ride along to a coding tool.

The gateway shipped: Claude, Cursor, or any MCP-capable client can read your derived understanding — never raw conversations, never your Vault — through scoped, revocable tokens. Every single read lands in an access log you can open. This is the feature the whole product was pointed at: explain yourself once, and the AI you open next already knows.

A gating bug: without signing in you could open and create projects — and reach export and delete-memory. Fixed the same day, with a rule we keep: the login wall goes on the specific account-tied action, not the whole screen. Browsing and chatting stay open; touching your stored memory requires being you.

Some things you want help with but never want uploaded. The Vault runs entirely on your device: local chat over encrypted files, a scanner that flags what looks sensitive, and boundaries the cloud pipeline cannot cross. Nothing in the Vault is ever extracted, synced, or shared — by construction, not by policy.

Each project can now hold a plan as a living document: propose, save, see status, diff any two versions, export with names redacted. Live-testing against a real model found two genuine bugs before launch — which is why we never call a feature done on unit tests alone.

Opening a project now lands you in its workspace: the report of what Lethe understands about it, plus a chat grounded in that project — and the chat persists and syncs, so Tuesday’s thread is still there on Friday.

Importing your ChatGPT or DeepSeek history used to end in silence. Now it ends in “here’s what I found”: the people, projects, and patterns it understood, each with its evidence — so the first thing you feel is recognition, not a spinner.

Consultants, founders and researchers don’t need different products — they need different views over the same understanding. The workspace shipped as exactly that: one graph of your work, viewed as clients, projects, or research threads, with an attention view for what needs you, an audit trail, and export of everything.

A memory toggle shipped: Adaptive learns from the conversation; Incognito guarantees the conversation leaves nothing behind. Not “remembers less” — remembers nothing. Some conversations are only safe to have with that switch visible.

Our assistant’s constitution said “never assume — ask.” Watching real sessions showed the opposite failure: it asked permission for things any colleague would just do. The rule was rewritten — make the reasonable assumption, say what you assumed, reserve questions for the genuinely irreversible — and verified against a live model, where we found the old text literally contradicting itself.

The privacy router shipped: before an observation is written anywhere, the people in it become pseudonyms. The cloud knows “Person 2 moved the deadline”; only your device knows who Person 2 is. This is the line the later name-display work and the Person-1 disclosure both stand on.

The first product build around the engine: you chat, Lethe extracts what mattered, asks you to confirm it, and remembers — a web app with the engine behind a clean seam, so the understanding isn’t welded to one interface. The first time the loop closed end-to-end on a real conversation is the day this stopped being a spec.

The extraction engine was validated live against a second model family and it became the default. What we actually proved: the engine’s quality lives in its structure — the schemas, the evidence rules, the confirmation gates — not in any one vendor’s model. That independence is what lets us pick models on merit and price.

Where this journey starts: the understanding engine’s foundations were frozen in writing — what it stores, what counts as evidence, what it refuses to guess — before the product around it existed. Every decision since gets written down the same way before it gets built. Slower for a week, faster for a year.