Every AI assistant your organization uses today has the memory of a goldfish. It forgets you the moment the conversation ends.
The industry's fix has been to bolt on external "memory systems" — databases that quietly store past conversations and feed them back into the AI when needed. That works, but it creates cost, complexity, and, increasingly, security incidents.
We tested a different approach. We taught the memory directly into the model itself. On the industry-standard test for long-term memory, called LOCOMO, we scored 99.95%.
This article explains what that means, what it doesn't mean, and why the technique matters for anyone responsible for AI strategy or AI risk.
Why AI Forgets — And Why That's a Problem
Imagine hiring an employee who, every morning, walked in with no memory of the day before. You'd have to re-explain your business, your customers, your preferences, and last week's decisions — every single day.
That's roughly what it's like working with today's large language models. Extraordinarily capable in the moment. Extraordinarily forgetful the moment the moment ends.
For consumer chat this is merely annoying. For the enterprise, it's expensive and risky.
Expensive, because every conversation reloads the same context — customer history, policy documents, prior decisions — and every reload is billed by the token.
Risky, because the workaround the industry has adopted — storing past conversations in a shared database and pulling them back in on demand — has produced a growing list of incidents where one user's memory leaks into another user's session.
Memory, it turns out, is not a feature. It's an architecture decision. And most enterprises are making that decision by accident.
The Two Ways to Give AI a Memory
Approach A: Keep a library next to the AI.
The AI itself stays forgetful, but every conversation is chopped up, indexed, and stored. When a new question comes in, the system searches the library, grabs the relevant pages, and staples them to the front of the question before sending it to the AI.
This is called Retrieval-Augmented Generation, or RAG. It's what almost every "AI with memory" product on the market does today.
It's flexible and easy to update. But every query pays a token tax as the same context is re-sent again and again. The library is often shared across customers, which is where the leakage headlines come from. And the search step can fail silently — grab the wrong page, and the AI confidently answers the wrong question.
Approach B: Teach the information into the AI itself.
The way a new hire eventually internalizes your company's playbook and stops needing to look things up.
Technically, this is done through post-training — a lightweight, targeted continuation of the model's original training, focused specifically on the material you want it to remember. Until recently, post-training was expensive and exotic. In 2026, thanks to techniques like LoRA (which teaches a model efficiently) and quantization (which shrinks a model without losing quality — the area our BBQ work sits in), post-training has become fast, cheap, and accessible to almost any capable team.
The upsides are structural:
No token tax at query time, because the memory lives inside the model itself.
Per-customer isolation by construction, because each tenant gets their own model, and one tenant's model literally cannot see another tenant's data.
Runs on-device, meaning the model with its memory can live on a laptop, a factory-floor machine, or an air-gapped server, with nothing leaving the building.
The trade-offs are equally real. Updating is slower than editing a database row. Deleting a specific fact is harder than deleting a database row — which matters under privacy regimes like PIPEDA and GDPR. And parametric memory is better at remembering what it was taught than at reasoning about brand-new conversations it has never seen.
What the 99.95% Actually Means
LOCOMO is the most cited benchmark for long-term conversational memory. It simulates conversations that stretch across dozens of sessions and months of simulated time, then asks the AI questions that require remembering, connecting, and reasoning across everything that was said.
We post-trained a model on a LOCOMO conversation set and scored 99.95% — essentially perfect recall.
Let's be direct about what this does and doesn't prove.
It proves that parametric memory works. When a model is taught a conversation, it can recall and reason over that conversation with near-perfect fidelity, using none of the retrieval machinery the industry currently treats as mandatory.
It does not prove that our model is somehow better at memory than any other model. We trained on the same material the test uses. On purpose. Because the point of the exercise was not to win a leaderboard — it was to measure the ceiling of what post-training can do as a memory mechanism, now that post-training has become cheap enough to be a serious architectural choice.
To make that distinction rigorous, we're proposing an extension to the benchmark, LOCOMO-Δ, that holds conversations back from training so the field can measure generalization separately from recall. The community deserves to measure the right thing.
Why the CEO Should Care
Cost curves are about to flip. Most enterprise AI budgets are being eaten by tokens, not by GPUs. Every RAG query re-sends the same context over and over. Parametric memory pays a one-time teaching cost and then runs cheaply forever. For any workload queried repeatedly — customer support, internal knowledge, sales enablement, compliance — the math starts favoring parametric memory somewhere between hundreds and thousands of queries. Most enterprise workloads clear that threshold within a week.
On-device AI becomes real. A model with its memory baked in can run inside your building, on your own hardware, with no calls to anyone's cloud. For organizations where data residency, sovereignty, or offline operation matters — regulated industries, government, healthcare, defense, resource sectors — this is the first architecture that makes serious long-term AI memory viable without a hyperscaler dependency.
Post-training is now a strategic capability, not a research project. The teams that treat post-training as a routine operation — the way they treat deploying a new version of an app — will build AI capabilities their competitors cannot easily replicate. The teams that outsource all of it to a foundation-model vendor will keep paying the token tax and keep inheriting whatever memory architecture that vendor happens to favor this quarter.
Why the CISO Should Care
Tenant isolation stops being a policy and starts being a physical property. With shared retrieval systems, isolation is enforced by configuration — a filter, a tag, a permission check. Configuration fails. With parametric memory, each customer's knowledge lives inside a different set of model weights. There is no shared store to misconfigure. The isolation is architectural, not procedural.
Data residency becomes trivial. A parametric-memory model is a file. It sits where you put it. It does not phone home. For Canadian organizations bound by federal sovereignty standards — data in transit and at rest on Canadian soil, owned by Canadian-owned entities — this is the cleanest posture available today.
The known weaknesses are auditable. Parametric memory has real limitations, particularly around updating and deleting, but those limitations are bounded and testable. Contrast that with retrieval-based memory, whose failure modes — wrong document retrieved, leaked context across tenants, prompt injection through retrieved content — are increasingly showing up in incident reports across the industry.
We're not arguing parametric memory is safer than retrieval in every case. We're arguing it has a different, more auditable risk surface — and that most security teams have not yet been offered the choice.
The Honest Answer: Use Both
The right architecture for enterprise AI memory is not parametric or retrieval. It's both, chosen deliberately.
Parametric memory should carry the stable, high-value, per-tenant knowledge that deserves to live in the model itself — your playbooks, your policies, your product knowledge, your recurring customer context.
External memory should carry the volatile, user-owned, or regulated data that needs to be edited, deleted, or audited on demand — recent transactions, user preferences, anything under a right-to-be-forgotten regime.
Most enterprises today are using one tool for both jobs. That tool is almost always retrieval. Usually because it was the only tool on offer.
That is beginning to change.
What We're Releasing
Alongside this article, we're publishing the post-training recipe we used, so any team with modest hardware can reproduce it; a BBQ-quantized checkpoint small enough to run on a high-end laptop; and the LOCOMO-Δ protocol proposal, so the broader research community can measure parametric memory fairly.
The 99.95% is a headline. The real story is that the tools required to get there have quietly become accessible to almost everyone. Enterprise AI memory is about to look very different — and the organizations that understand the choice before it is made for them will be in a much better position than the ones that don't.
Whether you're navigating Canadian data sovereignty requirements, operating in a regulated industry, or looking for a more secure and efficient approach to enterprise AI memory, Backboard gives you the infrastructure to start building.
Your AI memory architecture is a choice. Make it deliberately.
Book a demo today backboard.io
Rob Imbeault
SHARE