You know that feeling when you’re talking to ChatGPT and it remembers something you said three weeks ago? It’s a little magical. But then you switch to Claude, and it’s like you’re starting from scratch. You have to re-explain everything. Your context, your preferences, your entire digital self — it resets every time you change apps.
So someone built a fix. A shared memory graph that works across Claude and ChatGPT, using something called MCP (Model Context Protocol). It sounds great. One unified memory for all your AI assistants. No more repeating yourself. No more fragmented context. Finally, your AI remembers you everywhere.
But here’s the thing nobody’s talking about: Whoever controls your memory graph controls you.
Let me introduce you to the product. It’s called UML (Universal Memory Layer) — a service that stores your personal ‘memories’ as a graph on their servers. Your AI assistants connect to it via MCP, and suddenly they all know your coffee order, your project deadlines, your pet’s name, your deepest frustrations. Sounds convenient, right?
One commenter on Hacker News said: ‘giving you all of my "memories"? nah im good ;)’ — and they nailed it. That gut reaction is exactly the right one. Your memories are not just data points. They’re the story of your life. And you’re about to hand them over to a third-party server.
I’ve been watching this space for a while, and I’ve seen this pattern before. Centralized identity, centralized social graphs, centralized email. Each time, the promise was convenience. Each time, the cost was control. Memory is the new vendor lock-in, but this time it’s not just your data — it’s your cognitive context.
Think about it. If you store all your AI memories in one place, switching AI assistants becomes trivial. But switching away from the memory layer? That’s almost impossible. Your entire history lives there. Your relationships, your work, your thoughts. The LLMs themselves become interchangeable — commoditized compute endpoints. The real value is in the memory graph. And that’s owned by a single company.
One Hacker News user wrote: ‘Great idea, no one’s ever tried that before’ — dripping with sarcasm. Because we’ve seen this movie. The promise of seamless integration, the gentle creep of dependency, the eventual lock-in. The product is even named UML — which stands for Unified Modeling Language to some, but here it’s just a confusing acronym. Another commenter called it out: ‘You call it UML? Really?’
But here’s the twist: the product itself is actually well-designed. The creator clearly put thought into it. It works. And that’s what makes it dangerous. It’s not a scam. It’s a genuinely useful tool that solves a real pain point. And that’s exactly how the most insidious dependencies start.
So what’s the solution? Don’t use it? That’s naive. The demand for cross-model memory is real. The market will reward whoever solves it. But the solution must be decentralized. Your memory graph should be yours — encrypted, local, portable. Not outsourced to a cloud server where you’re the product.
Or maybe you’re fine with it. Maybe you trust the provider. Maybe you think the convenience is worth the privacy trade-off. But remember: the moment you hand over your memory, you lose the ability to leave.
FAQ
Q: Isn't this just a natural evolution of AI assistants?
A: Yes, it's natural — but natural doesn't mean safe. The problem isn't the concept of shared memory; it's the centralization. If the memory is stored on a third-party server, you're giving up control. The real evolution should be local, encrypted, and portable.
Q: What's the practical implication for users?
A: If you start using this product, you'll get seamless AI context across assistants. But you'll also become dependent on that provider. Switching away means losing all your memories. That's a huge switching cost. The practical implication: you're trading short-term convenience for long-term lock-in.
Q: Is there a safer alternative?
A: Ideally, memory should be stored locally on your device, with encryption and user-controlled access. The MCP protocol itself isn't the problem — it's the architecture. A decentralized memory graph (like a personal AI server) would be safer. But that's harder to build and less convenient. The trade-off is real.