u/sandstone-oli

Every team building AI applications with persistent context hits the same wall in the same order:

1.	Start with a vector DB and RAG. Works great for demos.

2.	After a few weeks, retrieval starts surfacing stale context. Build custom ranking logic.

3.	After a few months, users report the AI “feels dumber.” Realize the store is bloated with outdated facts competing with current ones. Build invalidation logic.

4.	Realize summaries have drifted from source truth. Build correction logic.

5.	Enterprise customer asks for an audit trail. Build provenance tracking.

6.	Look up from your desk and realize you’ve built an entire memory governance system you never planned to build.

Every team independently arrives at step 6. The vector DB was just storage. Everything built on top was the actual product.

We’re building KAPEX (getkapex.ai) so teams can skip steps 2 through 6. Memoryware. Memory infrastructure where relevance governance is handled automatically. Context that stops being reinforced through usage deprioritizes on its own. Every entry has provenance. The store self-maintains instead of degrading until someone manually prunes it.

Ran a 1,655 person blind study. First sessions, every approach looks equivalent. After sustained use, governed memory pulled ahead to 80%+ preference because the governance gap only shows up once the store has enough history to go wrong.

Self-hosted or managed cloud. Portable. Inspectable. Patent pending.

Curious how other builders here are handling memory governance. Are you at step 2, step 4, or already deep in step 6? And would you adopt a third-party governance layer or do you want to own that logic yourself?

Every app advertises long-term memory now. Most of them can barely hold onto your name for a week.

Here’s what’s actually happening under the hood on most platforms:

1.	Your conversation lives in a context window. That window has a size limit. Once it’s full, your earliest messages get dropped or compressed. The AI doesn’t “forget” — the messages literally aren’t there anymore.

2.	Some platforms save facts separately (your name, your job, basic preferences). That’s the “memory” they’re advertising. It’s a sticky note, not a relationship.

3.	Nothing governs what’s still relevant. A preference from month one and a preference from yesterday have the same priority. A joke gets stored as a real fact. Old context competes with current context and retrieval becomes a coin flip.

4.	When the platform updates their model or changes pricing tiers, your context can reset entirely. You built something over weeks and it’s gone because someone made a business decision.

The fix isn’t finding the right app. It’s having a memory layer that works regardless of which app you’re using.

That’s what we’re building at KAPEX (getkapex.ai). Memoryware. Memory infrastructure where context actually persists, relevance shifts over time naturally, and your history doesn’t vanish when a company ships an update.

Not a companion app. The layer underneath that would make all of them stop doing this.

What’s your experience been? Which apps actually maintain memory past the first week and which ones just pretend to?

I keep seeing posts here about AI companions forgetting weeks of deeply personal conversations after an update or model swap. For most use cases that’s annoying. For people using AI as part of their mental health support, it’s genuinely harmful.

Your recovery isn’t linear. The context of where you’ve been is what gives meaning to where you are now. When a platform resets that context because they changed their backend, they’re not just losing data. They’re erasing the narrative arc that made the support meaningful in the first place.

The problem isn’t that AI memory is hard. It’s that memory lives inside the platform rather than belonging to you. If you switch apps or the company makes a business decision, your context goes with it.

We’re building KAPEX (getkapex.ai) to fix this. Memoryware for AI applications. The memory layer sits outside any specific platform so your context persists regardless of what happens underneath. Relevance is governed automatically so old context that’s no longer part of your current journey doesn’t compete with where you are today.

Ran a study with 1,655 people. The value didn’t show up in the first session. It showed up after sustained use when the system had enough history to actually understand what matters. Preference climbed past 80% over time.

Not a therapy app. Not a companion. The infrastructure layer that would make any of them actually hold onto who you are.

Curious if others here have lost important context to a platform change and how it affected your experience.

We’re building KAPEX (getkapex.ai), memoryware for AI applications. Two co-founders, bootstrapped, patent pending. I wanted to share some of what we’ve learned because the discourse in this space keeps circling the same assumptions and I think a few of them are wrong.

The study: 1,655 participants interacted with AI systems with and without our memory layer. Blind setup, they didn’t know which condition they were in.
The finding that mattered most: first-session preference was around 65%. Not bad, but not a clear signal. After 20+ sessions, preference climbed past 80% and kept rising. The longer people used it, the wider the gap.

That trajectory is the insight. Not the final number. The trajectory.

Here’s why that matters for anyone building in this space:

Most AI memory tools are optimized for first impressions. Demo well, retrieve fast, show the user you remembered their name. That’s fine. But it means the entire evaluation framework for memory (including the benchmarks everyone cites) is testing the wrong thing. LongMemEval and LoCoMo test whether you can find what was said. They don’t test whether the system knows what still matters.
Retrieval and relevance are different problems. The industry has spent two years building better retrieval. Almost nobody is building relevance governance: what stays important, what fades, what gets superseded, and whether the user can see and correct what the system believes.

Three things we learned the hard way:

1.	Clean store beats fancy retrieval. Every time. If your memory layer lets stale context accumulate without governance, no amount of reranking or hybrid search fixes the degradation over time. The capture and maintenance side is where the leverage actually is.

2.	Memory without transparency is a black box. If developers can’t see why the agent believes something, and users can’t see what the system thinks it knows about them, then memory becomes a liability rather than a feature. Inspectability isn’t a nice-to-have. It’s what makes correctability possible.

3.	The value of memory is invisible in short sessions. This is why benchmarks miss it. A 5-turn evaluation can’t distinguish between a system with real governance and one that just retrieved the right vector. The difference only shows up after sustained use, which is also when it matters most.  

Our approach treats relevance as something that should be handled continuously by the architecture, not at query time by the retrieval layer. Context that stops being reinforced through usage naturally loses priority. Not deleted, just deprioritized. That’s the principle. Can’t share more on implementation for IP reasons.

Curious what others here are seeing. Is anyone else finding that the retrieval-first paradigm breaks down over time? And is anyone working on evaluation frameworks that test sustained-use performance rather than single-session recall?

getkapex.ai if you want to follow along. Still pre-launch but opening access soon.