You built the retrieval system carefully. The prompts worked, the retrieval logic worked, and the outputs were validated. Then the model was deprecated. You upgraded, and the system kept working. The answers still looked correct. What changed was invisible.
The new model interpreted your data differently. It chose a different entry point for the same class of query. The reasoning was coherent. The retrieval population was now wrong. Entire branches of relevant records disappeared. Unrelated material entered. No error, no failed test, no alert. The governance failure was silent.
This happens because in most enterprise AI deployments, the meaning of your data is resolved at runtime by a probabilistic model. Its interpretation of which entities are equivalent, which relationships matter, and which entry point is correct for a given query is re-derived on every call, changes across model versions, and is never stored. Your enterprise is being rediscovered from scratch on every query.
The fix is not a better prompt. It is a governed semantic registry.
"A perfectly traceable runtime query can still be semantically wrong. Observability shows you what was retrieved. It does not tell you whether the retrieval population was correct."
What a governed semantic registry is
A governed semantic registry is a versioned, human-approved mapping from the surface forms that appear in your data to canonical identifiers that carry defined scope boundaries. It sits between your enterprise data and your AI retrieval layer. When new content enters the system, an LLM reads it, extracts candidate terms, and searches the registry for matches. High-confidence matches are tagged automatically with the canonical identifier. Low-confidence matches go to a human reviewer before the tag is applied. At query time, the LLM resolves the user's intent to a canonical identifier and retrieval runs deterministically against everything tagged with that identifier.
The model does not decide what your data means at query time. It decided once, at ingestion, under human oversight. That decision is stored, versioned, and auditable. If the model is upgraded or replaced, the semantic state is unchanged because it lives in the registry, not in the model.
LLM searches the registry as a governed reference
The registry entry is not a synonym list. It carries dimensional constraints: the division it belongs to, the regulatory domains it covers, the jurisdictions in scope, and an explicit retrieval boundary defining what it excludes. A query for "valuation risk" retrieves every document tagged with RISK_ENTITY_1042. The retrieval boundary prevents silent scope expansion into adjacent risk categories a runtime model might otherwise consider relevant. The scope is governed, not inferred.
Why the problem cannot be solved at runtime
Before explaining what the registry does, it is worth being precise about what it replaces and why that replacement is necessary rather than optional.
The instinct when retrieval goes wrong is to add more rules: specify the traversal path more precisely, add more constraints to the orchestration layer, enumerate the relationships that matter. This has a ceiling. You cannot govern semantic exploration by enumerating rules for every possible relationship across an enterprise data estate. The combinatorics defeat the approach before the governance value is realised.
The deeper problem is that runtime semantic resolution is the wrong place for governance-critical decisions to live. When meaning is resolved during query execution, it is transient. Not stored, not versioned, not inspectable independently of the model that produced it. If the model changes, the meaning changes with it. There is no semantic state to audit. The registry is what creates that state.
What the registry changes about the LLM's role
The LLM does not disappear in this architecture. It moves. In a runtime-discovery system, the LLM resolves semantic meaning during query execution. Every query is a fresh inference. The model decides what the user probably meant, which entities are equivalent, and which data is relevant. None of this is stored. If the model changes, those decisions change with it.
In the governed registry architecture, the LLM does its semantic work at ingestion time. It extracts terms, proposes matches against the registry, and flags low-confidence cases for human review. The output is a document tagged with canonical identifiers that were validated before the document entered the retrieval system. At query time, the LLM resolves the user's natural language intent into a canonical identifier. Retrieval runs deterministically against everything tagged with that identifier. The model's probabilistic nature is contained to the two steps where natural language interpretation is genuinely needed. The retrieval itself is governed.
In mature systems the LLM takes a further role: surfacing new terms that no existing registry entry covers and proposing candidate additions. Governance processes approve or reject those proposals. The LLM is proposing. Humans are approving. The registry is the authoritative record. The model cannot change the meaning of your data unilaterally.
What this makes possible that was not possible before
Three things change when semantic meaning is governed rather than inferred.
First, model upgrades stop being retrieval events. When a new model is deployed, the canonical tags on all existing documents are unchanged. The new model may extract and match terms differently on new content entering the system going forward. It does not reinterpret content that has already been tagged. Deprecation and migration no longer silently alter what your retrieval system returns.
Second, coverage failures become detectable. When a query returns results, you can verify whether every document tagged with the relevant canonical identifier is in the result set. If it is not, there is a specific, inspectable failure. Coverage stability becomes a measurable property rather than an assumption.
Third, governance claims become substantiatable. If a regulator, a client, or a board asks how you know that a query for "model risk" retrieved all relevant material and nothing irrelevant, there is an answer: every document in scope was tagged with RISK_ENTITY_1042 during ingestion, under human oversight, using a versioned registry entry approved by the Risk Governance Committee on a specific date. That is an auditable chain. Runtime inference cannot produce one.
The governance tax and why it is worth paying
A governed semantic registry has real costs. Every document entering the system must pass through the extraction and matching pipeline. Semantic versioning must be maintained. When definitions change, migrations must be planned, approved, and executed. The infrastructure is less flexible than a runtime system precisely because its semantic state is explicit rather than implicit.
These costs are not flaws. They are what it means to take governance seriously. A runtime-heavy system externalises the same costs into probabilistic reinterpretation on every query. The cost does not disappear. It becomes invisible, and it is paid in coverage failures that are never detected, retrieval populations that drift across model versions, and governance claims that cannot be substantiated.
If your organisation needs to claim that its AI retrieval is governed, that claim requires a semantic state that is stored, versioned, and inspectable. Runtime inference cannot support that claim. The stage is the unit of governance. Not the prompt, not the output, and not the model. The governed semantic registry is what makes the retrieval stage auditable rather than merely observable.