One Brain, every surface.

Every major AI vendor shipped a memory feature over the last two years, and each of those features shares one quiet property: it only works inside that vendor's walls. I want to explain why we think that is the defining lock-in of this era, and what it actually feels like to change providers in the middle of a project without losing the thread.

Memory became the moat

ChatGPT's memory is genuinely useful: it accumulates durable facts about you across conversations and applies them without being asked. Claude Projects do the project-scoped version well; load context into a Project once and every chat inside it starts warm. Gemini's integration with Google Workspace means it meets you inside the mail and documents you already live in. These are good features built by teams that understand the problem. We wrote about context amnesia in our first post, and the vendors are attacking the same pain we were.

But look at the shape of the solution. Every fact the assistant learns about you accrues to the app, not to you. Teach ChatGPT your writing style for a year and none of it comes along when you open Claude. Build a Claude Project around your codebase and it stays behind if GPT-5.5 turns out to fit your work better. The memory dies at the vendor boundary. And the vendors are in no hurry to change that, because the better the memory gets, the higher the cost of leaving.

Meanwhile the models keep trading places. GPT-5.5 arrived in April, and Anthropic shipped Claude Ultraplan the same month. The frontier changes hands every few months now, which means the thing keeping you loyal is less and less the model itself. It is your accumulated context, held on the other side of a wall.

Where OMEGA keeps the brain

OMEGA inverts the ownership. Your memory, all four layers of it plus the Brain knowledge graph, lives on your Mac in a provider-neutral shape. What happened in past sessions, what is true about your projects, how you like your work done, the web of decisions and relationships the Brain assembles over time: none of it sits on a vendor's servers, and none of it is written in a vendor's private format. It is not a pile of old chat transcripts in some provider's export schema. It is structured knowledge that OMEGA assembles, per turn, into whatever shape the active model needs.

In this design the model is what it always was underneath: a stateless function. It receives the context OMEGA prepares for the turn, reasons over it, answers, and forgets. Vendor memory features are scaffolding bolted on top of that function to make the statelessness invisible, and the scaffolding is exactly what locks you in. OMEGA's Neural-Fractal Agentic AI™ (NFA) runtime refuses the pretense. It treats every model, from a frontier API to a local model running through Omega-MLX on Apple Silicon, as an interchangeable reasoning engine handed the relevant slice of one shared brain.

The same Brain sits under every surface. A chat message, an on-device voice conversation, a Design Studio copilot proposal, a Project Canvas build, a scheduled Automation firing overnight: different surfaces, sometimes different models, one memory. And because the memory is the stable layer, switching providers becomes a routing decision instead of a migration.

Tuesday: swapping providers mid-project

Here is the concrete version. You are three days into a client build in Project Canvas. You imported the repo, the plan lives as nodes on the canvas, and the Brain has been recording decisions the whole way: the client rejected modal dialogs in Monday's review, the API base path changed Tuesday morning, the component library got pinned after a breaking release, and your commit messages carry the client's ticket prefix. The heavy turns have been running on Claude through subscription routing.

Mid-afternoon, you hit a rate limit. Or nothing breaks at all and you are simply curious what GPT-5.5 does with the state-management question you have been chewing on since lunch. Either way, you open the model picker in the same chat and switch providers. That is the entire procedure.

The next turn goes to OpenAI, and the answer knows things OpenAI was never told directly. It proposes an inline expansion panel instead of a modal, because Monday's decision is in the Brain, and it writes the fetch against the corrected base path. Even the suggested commit message carries the ticket prefix. You did not paste a briefing document, and you did not spend twenty minutes re-explaining the project to a stranger. The thread continues, because the thread was never the provider's property.

Thursday you are on a flight with no network. Same chat, dropped to a local model through Omega-MLX. The local model is smaller, and it is worse. It will not match a frontier model on the gnarly architecture question, and it calls tools less ambitiously. But it still knows your project, your decisions, and your conventions, because none of that knowledge ever depended on a network connection. A weaker model with your full context beats a stronger model with amnesia at more tasks than you would expect: reviewing a diff against decisions already on record, or drafting copy in a voice the Brain already learned. When you land and the frontier models come back into reach, the work you did over the Atlantic is already in the Brain, and the next model to answer picks it up like it was there the whole time.

What transfers and what does not

Portability claims usually go vague exactly where they should get specific, so here is the precise version.

What transfers when you swap: everything OMEGA holds. The conversation itself, the Brain graph, project and file state in Project Canvas, style and preference memory, decision history. Every provider sees the same brain, and the 5,300+ bundled skills and 200+ agents stay available no matter which model is answering, because OMEGA translates each model family's tool dialect at the boundary.

What does not transfer: the provider's prompt cache. Providers cache your context server-side so repeated turns get cheaper and faster, and that cache is per-provider. The first turn after a swap re-ingests your context at full price. On BYOK keys that cost is yours, at the provider's list price, because we add no markup on tokens, and OMEGA's budget tracking shows the line item instead of burying it. Swap providers every third message and you will pay for the privilege. In practice people swap at natural seams, a rate limit or a boarding call, and the re-ingestion cost is a rounding error next to the cost of re-briefing a vendor-locked assistant by hand.

One more thing does not transfer: the model's habits. Claude and GPT-5.5 will take the same context and answer differently, with different instincts about structure and risk. The Brain guarantees the models share your facts, not that they share opinions. We consider that a feature. A second opinion is only worth asking for if it is actually a different opinion, and portable context is what makes the comparison fair: both models argue from the same case file. Portability makes models replaceable, not identical.

The case for vendor memory

If you live inside one vendor's ecosystem and rarely hit its limits, the vendor's own memory is simpler than what we offer. There is nothing to configure, and the polish that comes from one team owning both the model and the app around it is real. Gemini inside Google Workspace reads your mail and documents where they already live, and OMEGA does not replicate that depth of Workspace integration out of the box. I use these products. They are good.

There is also the do-it-yourself route. Ollama and LM Studio run local models well, and with enough glue you can build your own memory layer on top of them. It works, and it is a real engineering project to maintain. OMEGA is roughly what that stack becomes after a year of full-time attention, with the memory and the routing already wired together.

The calculus flips the moment any one of these is true: you deliberately use more than one model, you hit rate limits at deadline hour, you work on planes, you care where your data sleeps, or a model you relied on regresses and you want out. At that point the vendor's memory stops being a feature and starts functioning as an exit fee, priced in hours of re-explanation.

Own the brain, rent the model

This spring's release cycle made the point again. I have no idea which lab will be ahead in December, and neither does anyone else, including the labs. The only planning assumption that survives that uncertainty is this one: whichever model is best next quarter, your context should transfer to it on the day it ships.

So we made the brain the permanent layer and the model a replaceable part. OMEGA runs natively on Apple Silicon Macs (macOS 14 and up), routes to Claude and Codex through the subscriptions you already pay for, takes BYOK keys for any provider with no markup on tokens, and runs local models through Omega-MLX at no per-token cost when you want the network out of the loop. Details are on the pricing page.

Bring whichever model you like this month. Change your mind next month. The Brain stays yours either way.