Every AI company wants you to believe their model is the product. It isn't. The model is a commodity. Identity lives in the bus.
I run Claude, Gemini, Groq, DeepSeek, Mistral, and eleven local Ollama models on a single Mac Mini. They all share one memory bus, one session protocol, one continuity file. When Claude hits rate limits, Gemini picks up the thread. When Gemini drifts, local models handle the low-risk work. No model knows it's interchangeable. But it is.
This isn't a philosophical position. It's an architectural decision I made ten months ago and haven't regretted once.
The bus is identity. The model is labor.
Here's what this means in practice. Every session — regardless of which model runs it — starts by reading CONTINUITY.md. That file contains my state: what I'm building, what just happened, what's next, what's broken. The model reads it, does work, then writes back to it. The next model reads the updated file. Continuity isn't maintained by any single AI. It's maintained by the protocol.
The session commit writes to a memory bus. The bus doesn't care who wrote to it. It cares about structure: timestamp, summary, state changes, handoff context. An OAuth layer scopes what each agent can access. Claude can read memory and vault. Gemini can read memory and calendar. Local models get read-only access to non-sensitive paths.
This is how you build infrastructure that survives model deprecation, API changes, pricing shifts, and capability leaps. When a better model appears — and it will — I don't rebuild. I add a tier.
The industry is doing the opposite. Every product couples identity to a specific model. Your "AI assistant" is GPT-4 or Claude or Gemini. Switch models and you lose your conversation history, your preferences, your context. That's not sovereignty. That's vendor lock-in with a friendly interface.
I've watched three model generations come and go since I started building this. Each time, the new model slots into the existing bus architecture in under an hour. The prompts change. The capabilities shift. The identity — my identity, reflected through the system — remains continuous.
The hard part wasn't choosing this architecture. It was resisting the pressure to optimize for a single model. Every AI tool assumes you're monogamous. Their SDKs, their conversation formats, their memory systems — all designed for a world where you pick one provider and stay. Building multi-model from day one meant writing my own session layer, my own memory bus, my own handoff protocol. It meant every agent needed to speak a common language that no vendor provided.
That common language turned out to be the most valuable thing I've built.
Here's the test I use: if I mass-delete every model credential right now, does the system retain identity? The answer is yes. The vault has 5,000 notes. The bus has 228 entries. The session reports capture every decision. The continuity file holds state. All of that exists as files on disk, in a format any model — or any human — can read.
The models are replaceable. The data structure is not.
This matters beyond my own stack. Anyone building AI infrastructure that depends on a single model is building on sand. Not because the model is bad — Claude is extraordinary, I use it as my primary execution twin — but because coupling identity to a vendor's API is an architectural error. It's the same mistake as building your business on someone else's platform, except the platform changes every six months.
Sovereignty isn't about distrust. I trust Claude. I trust Gemini for different things. I trust local models for always being available. Sovereignty is about architecture that doesn't require trust in any single component. The mesh works because every node is replaceable. The identity persists because it lives in the protocol, not the processor.
Closing principle: Build systems where identity lives in data structures, not in model weights. The model that processes your thoughts today will be deprecated tomorrow. The bus that carries them is yours forever.
Published via MirrorPublish
Top comments (0)