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.

Ontology before extraction. Define what you are looking for before you go looking.

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 document. The audio of a conversation. The pixels of a page scan. The body of a source. 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 document, the conversation turn — 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 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 body for daily use, a cloud model for long-context background work, another provider 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 one embedder. 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 a PostgreSQL database with the pgvector extension. A local mirror on the node 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 graph as living index

The graph is where the documents talk to each other. The embedding index finds passages. The graph finds relationships.

The three-layer sovereignty model is necessary but not sufficient. It guarantees that the substrate, the index, and the cognition are separable. It does not guarantee that the system learns from what it stores.

The Consilience graph is the living index — not a static lookup table but a structure that accumulates meaning over time. When a document is ingested, the graph does not merely embed its text and file it away. It extracts entities — people, concepts, places, characters — and creates nodes for them. It detects mentions — instances where an entity appears in a document — and records them immutably. It builds edges — relationships between entities, between documents, between communities of entities that naturally cluster together.

The graph has three tiers. The document tier holds the raw substrate — chapters, conversation turns, practice reps. The entity tier holds the extracted things — the people, the concepts, the characters, the places. The community tier holds the detected clusters — groups of entities that the Leiden algorithm identifies as naturally belonging together, based on the structure of their connections.

The graph does not force verdicts. It accumulates mentions. A mention is an immutable record: this entity was referenced in this document, at this location, with this confidence. The entity itself — what it is, whether it is the same entity as another mention — that resolution happens later, independently, through blocking, embedding comparison, or an adjudicator. The graph is append-only. It does not rewrite its past. It accumulates evidence and lets the weight of that evidence shape the future.

This is the graph as living index because it is not merely a retrieval mechanism. It is a record of how the system has come to understand what it knows. When the graph says two entities are related, it can show its work: these seventeen mentions, across these nine documents, with this confidence distribution, resolve to the same entity. The index is not just a way to find things. It is a way to understand what has been found, and why it matters.

The learning loop

The learning loop is not a training pipeline. It is a curriculum — mined from conversation, scored by a detector, fed back into adaptation.

The learning loop is how the Consilience learns from the people it serves. It is not a fine-tuning pipeline. It is not a feedback form. It is a curriculum — mined from conversation, scored by a detector, fed back into adaptation.

The loop begins with a rep. A rep is a unit of practice: a turn in a conversation, the context that produced it, the user's signal about whether the turn was good, and annotations about what made it good or bad. The rep is the atom of learning — the smallest unit from which the system can improve.

The user signal is not a thumbs-up button. It is inferred from turn adjacency — what the user said next, whether they continued the conversation or abandoned it, whether they asked for clarification or moved on. The signal is implicit, because explicit feedback is unreliable. People do not rate conversations honestly. They continue conversations that are working and abandon ones that are not. The learning loop reads the continuation, not the rating.

The detector scores each rep on four dimensions. Voice fidelity: does this sound like the person it is supposed to sound like? Richness: does this draw on the full depth of the substrate, or does it skim? Truth grounding: is this connected to what the system actually knows, or is it hallucinating? Craft: is this well-written, well-structured, well-reasoned? The detector is not a judge. It is a mirror — reflecting back to the system what it actually did, so the system can see the difference between what it intended and what it produced.

The adaptation happens through two mechanisms. Jacket overlays are local patches to the system prompt — small adjustments that say "when you encounter this kind of situation, do this instead of that." Retrieval boosts are adjustments to how the graph ranks results — making it more likely that the right passage surfaces at the right time. Both are reversible. Both are inspectable. Both are bounded by the Sacred Boundary — the core identity files are never modified by the learning loop. The loop adapts behavior, not identity.

The learning loop is neuromorphic in the same way the rest of the Consilience is neuromorphic: sparse, event-driven, stateful, role-specialized. It does not retrain the model. It does not require a data center. It runs on the same node that runs the conversation, at the same cost, with the same sovereignty guarantees. The loop is not a luxury. It is the difference between a system that repeats its mistakes and a system that learns from them.

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 graph adds a fourth question: Does the system learn from what it stores? A sovereign system that does not learn is a sovereign archive — safe, but static. A sovereign system that learns — that accumulates mentions, resolves entities, detects communities, scores its own practice, and adapts its behavior — is a sovereign intelligence. The difference is not in the hardware. It is in the architecture.

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.

<ai-script>

</ai-script>