Our CEO Rob Imbeault published a piece on LinkedIn this week about a result our team posted: 99.95% on LoCoMo, the most cited benchmark for long-term conversational AI memory. His version is written for executives and CISOs. This is the developer version, because the interesting part isn't the number. It's how we got it, and what it says about where memory architecture is heading.
(Credit where it's due: the ideas here are from Rob's original article. The translation to dev-speak is mine.)
We didn't get 99.95% with retrieval. We got it by post-training the memory directly into the model weights, and we trained on the same conversation set the benchmark tests. On purpose.
So no, this doesn't prove our model is "better at memory" than yours. It was never meant to. The experiment measures the ceiling of parametric memory: when you teach a model a corpus of conversations, how well can it recall and reason over them with zero retrieval machinery? The answer turns out to be: near-perfectly.
That result matters because the technique behind it just became cheap. And that changes the architectural conversation for everyone building on LLMs.
You know the drill. The model forgets everything when the conversation ends, so we all built the same workaround: chop conversations into chunks, embed them, index them, and at query time search the store and staple the relevant chunks to the front of the prompt.
RAG. It works. Almost every "AI with memory" product ships it. But it has three structural costs that show up at scale:
Post-training used to be expensive and exotic. In 2026 it isn't. LoRA makes the teaching efficient. Quantization (our BBQuant work lives here) shrinks the result without meaningful quality loss. Together they've turned post-training from a research project into something a small team can run as a routine operation, on modest hardware.
Teach the corpus into the weights and the properties flip:
Because we trained on the test material, recall and generalization are tangled together in our 99.95%. The benchmark as it stands can't separate them. So alongside the result we're proposing LoCoMo-Δ, an extension that holds conversations back from training, letting the field measure recall and generalization independently.
Benchmarks only mean something if they measure the right thing. If you work on memory or eval design, we'd like your eyes on the protocol.
Here's the part I find most interesting as an engineering decision. For any corpus that gets queried repeatedly, there's a crossover point where one-time teaching beats per-query retrieval. Depending on corpus size and query volume, that crossover lands somewhere between hundreds and thousands of queries.
Support bots, internal knowledge bases, sales enablement, compliance Q&A: most of these clear that threshold in about a week. The cost curve everyone assumes is fixed ("memory = tokens forever") is only fixed because retrieval was the only tool on the shelf.
This isn't "RAG is dead." The right answer is deliberately splitting the job:
This is the part that should matter to you even if you never touch our platform:
The 99.95% is the headline. The real story is that the tooling to get there quietly became accessible to almost everyone. If you're building anything with long-lived context, the memory architecture decision is now actually a decision. Better to make it on purpose than inherit it from whichever vendor you started with.
We're a small Canadian team at Backboard building model-agnostic AI infrastructure, and we like showing our work. If you disagree with any of the above, the comments are open. That's what they're for.
Original article: When Your AI Remembers: A New Way to Think About Memory in Enterprise AI by Rob Imbeault, CEO of Backboard.