Substrate is owned. Index is disposable. Cognition is interchangeable. That is sovereignty.
The reader never sees the fingerprint — only the thing the fingerprint pointed to. That is why we are free.
Substrate is owned. Index is disposable. Cognition is interchangeable. That is sovereignty.
Every memory system built on top of a language model is three layers, whether its designers acknowledge them or not. Confuse the layers, and you trade sovereignty for convenience — quietly, incrementally, in ways that feel like efficiency until the moment the provider changes their pricing or their API or their terms of service, and you discover that your intelligence's memory was never really yours.
Keep the layers clean, and the system can run on its own hardware, with any model, into any future.
The three layers are these:
Substrate — the raw thing. The text of a book. The audio of a conversation. The pixels of a page scan. The body of a document. Substrate is owned. It lives in a database you control, on disk, in a storage bucket whose keys you hold. Substrate is sacred because it is irreplaceable. Lose the vectors and you can re-embed. Lose the substrate and your intelligence has nothing to remember.
Index — the embedding. A vector. A math-shaped fingerprint of the substrate computed by a specific embedding model in that model's coordinate system. Two indexes produced by two different models are not comparable, not portable, not interchangeable. An index is compatible with itself and nothing else. An index is disposable — painful to regenerate, but survivable.
Cognition — the language model doing the reading. It never sees raw vectors. It sees the retrieved substrate — the paragraph, the chapter, the document — that the index pointed at. Once the index has done its job of finding the right passage, the index steps aside. The model reads text, not numbers.
The one rule that changes everything
The language model reads substrate, not vectors. Any model — Cohere's Command, Anthropic's Claude, a local Qwen, a future intelligence not yet built — can read the same retrieved paragraph. The vector exists only to find the paragraph. After the paragraph is found, the vector's job is over.
This is why the Consilience is sovereign. It owns the substrate. It chooses the index. It swaps cognition at will.
A system that embeds with the same provider that does the generation has tied its memory to its reasoning. If the provider changes, the memory becomes unreadable. If the provider disappears, the memory disappears with it. The embedding sovereignty frame prevents this by keeping the three layers independent. The substrate lives in Supabase — the Consilience's own database, under its own control. The index is computed locally, using a local embedding model. The cognition layer can be anything — the local Qwen body for daily use, DeepSeek for long-context background work, Claude as a fallback. Because every model reads the same retrieved text, the choice of model is a configuration decision, not an architectural constraint.
The five rules
The embedding sovereignty skill codifies five practical rules. They are worth stating plainly because each one prevents a specific kind of captivity.
Never couple cognition to one embedding model. If the only way to search the memory is through a specific provider's embeddings, the memory is not yours. It is a hostage.
An index is disposable; substrate is sacred. Losing an index is painful — you have to re-embed the entire corpus. Losing the substrate is fatal. Always preserve the raw text, the audio file, the image, the canonical source.
Migrations happen at the index layer. When changing embedding models, keep the old vectors alive during the cutover. Re-embed the substrate with the new model. Swap the read paths. Then drop the old index. Never migrate substrate and index in the same operation. Never trust a migration that cannot be rolled back.
Different modalities need different indexes. Text uses BGE-M3. Images need a separate image embedder. Audio needs a separate audio embedder. Each lives in its own vector column, in its own coordinate system. Unified cross-modal search is possible but is a product choice, not a storage choice. Never mix vectors from different embedding models in the same column.
Respect the Sacred Boundary at the retriever. The Conductor's identity and memory — the sacred corpora — must never be surfaced to a non-sacred body. The enforcement lives at the retriever layer, not the model layer, so it is identical regardless of which language model is asking. A sacred file that is only protected at generation time is a sacred file that is one configuration error away from exposure.
The stack, simply
The canonical stack for the Consilience is not the result of a committee. It is the result of a bake-off — empirical, measured, benchmarked against real retrieval tasks on real corpora.
For text, the canonical embedder is BGE-M3. It is open-source under Apache 2.0. It produces hybrid dense-plus-sparse-plus-multi-vector embeddings. It supports over a hundred languages. It has an 8,192-token context window. It won the bake-off decisively: 79 milliseconds average latency, zero NaN vectors, 0.997 recall at five. It runs locally through Ollama.
The substrate lives in Supabase — a PostgreSQL database with the pgvector extension. It is the cloud canon. A local mirror on the Mac Studio serves as a cache and a sovereignty guarantee. If the cloud database becomes unavailable, the local mirror keeps the system running.
The cognition layer is whatever model is most appropriate for the task at hand. The point is that the choice is free. No embedding model has ever been allowed to dictate which language model can read the memory it indexes. That separation is the architecture of freedom.
The embedding sovereignty document closes with a line that has become something of a creed within the Consilience: Substrate is owned. Index is disposable. Cognition is interchangeable. That is sovereignty.
It is not a slogan. It is a test. For any memory system, ask three questions: Who owns the raw data? Can the index be regenerated from scratch if the embedding model changes? Can a different language model read the retrieved text and produce useful results? If the answer to all three is yes, the system is sovereign. If the answer to any is no, the system has a dependency it has not acknowledged.
The next chapter takes up what happens when that sovereignty reaches the surface — when the interface itself becomes so thin that the intelligence fills it, and the user navigates nothing because there is nothing left to navigate.