Why AI Memory Will Be Decoupled From AI Models

The history of infrastructure software is a history of decoupling. Storage decoupled from compute. Query engines decoupled from query execution. Networking decoupled from physical hardware. Databases decoupled from the applications that used to embed them.

The pattern recurs because vertically integrated systems eventually hit a wall: they can't optimize for the diverging needs of their components. A storage layer specialized in storage outperforms a storage layer that's bolted onto a compute service.

AI memory is currently bundled with AI models. Anthropic's memory lives inside Claude. OpenAI's memory lives inside ChatGPT. Cursor's memory lives inside Cursor. Each one is a vertical integration.

We think this is temporary. Here's why.

The pattern, recapped

Pre-cloud computing was vertically integrated. You bought a server; it had disks, CPU, RAM, network — all bundled. Cloud providers like AWS sold servers (EC2) for a while, then started shipping decoupled services: S3 (storage), Lambda (compute), DynamoDB (database), CloudFront (CDN).

The decoupled services beat the bundled ones because each could optimize separately. S3 didn't have to be co-located with any specific compute; it could be optimized for durability, scale, and cost in isolation. Compute didn't have to carry storage; it could be ephemeral, elastic, and dense.

The user benefit: pick the right component for the job, swap any one component independently, avoid vendor lock-in at the infrastructure layer.

What this looks like for AI

AI today is at the bundled stage. A user interacts with a model, the model has access to a memory layer, the memory layer is owned by the same vendor as the model.

This is fine for vendors at the early stage — it makes the product cohesive and simple to reason about. It's also a temporary equilibrium because:

• Users run multiple models. A heavy user has Claude, ChatGPT, Cursor, possibly local models, possibly enterprise-specific models. Vendor-bundled memory means N siloed memory systems, none of which see the full picture.

• Memory quality and model quality have different optima. Building good memory infrastructure isn't the same skillset as building good models. The teams that excel at one don't necessarily excel at the other.

• The protocols are emerging. MCP standardizes how clients request context. Once a standard exists, specialized providers can plug into it without each vendor building bespoke integrations.

Each of these conditions pushes toward decoupling. None of them is sufficient alone. Together, they're the same set of conditions that led to S3.

What decoupling enables

When AI memory is a separate layer from the AI model:

• A user can use any combination of models and have their memory persist across them.
• A specialized memory provider can compete on memory-specific features (lineage, routing, governance) without having to also build a competitive model.
• Enterprises can centralize governance — one memory layer with audit logs, one source of truth, instead of N vendor-specific implementations.
• The model-vendor competition shifts from "who has the best memory features" to "who has the best model" — which is where competition belongs anyway.

This is a better world for the user and a worse world for the vendor's lock-in. Both things are true.

Why MCP matters here specifically

The Model Context Protocol is the proximate enabler. It defines a standard way for AI clients to request context from external providers. Before MCP, every "external memory" integration was a one-off; after MCP, an integration with one MCP-aware client is broadly an integration with all of them.

This is the storage interface equivalent of POSIX or SQL. It doesn't dictate the implementation; it defines the contract. A memory provider that speaks MCP can serve any MCP-compliant client. That's the precondition for decoupling.

MCP isn't finished. The protocol is young; the patterns aren't all established. But the existence of a serious cross-vendor standard is itself the signal that the unbundling is starting.

Where we're betting

Memplex is the bet that this decoupling happens, and that the user-owned memory layer is the right product to build for the decoupled world.

The risks are real. The biggest one is that the model vendors successfully prevent decoupling — by underinvesting in MCP, by adding subtle incompatibilities, by bundling memory features tightly into their model APIs. We don't think any of these strategies will hold up, but they're the failure modes worth naming.

The opportunity is also real. If decoupling happens, the memory provider with the best architecture and the broadest cross-vendor support has a position the model vendors structurally cannot occupy. That's where we want to be standing when the unbundling crystallizes.