The principle at the center of the Look Up First pillar is this: before generating, retrieve. Before asserting, verify. Before reasoning, ground.

This sounds simple. The complexity is in what "retrieve" means when the domain has structure — when the knowledge you need is not just text but a web of entities, relationships, constraints, and rules that must be preserved intact for the AI to reason correctly.

Structured Context Retrieval (SCR) is the methodology we developed to solve this problem. This essay presents the production evidence: what SCR achieves in practice, how we measured it, and what the accuracy gap reveals about the nature of the problem.

The Methodology

SCR is defined formally as: a retrieval approach that preserves semantic structure during context assembly, maintaining the relationships that enable precise, deterministic operations. The key word is "preserves." Standard RAG does not preserve semantic structure — it converts structured knowledge into statistical similarity vectors and retrieves chunks.

SCR does something different. It treats the knowledge graph — the entity-relationship structure that encodes domain meaning — as the primary retrieval surface. Rather than chunking and embedding documents, SCR queries the semantic substrate directly, returning structured context that preserves entity identity, relationship types, and constraint hierarchies.

The practical difference: when the AI receives SCR context, it knows it is dealing with the concept "Product Version 3.2" specifically — not a text fragment that mentions version numbers. It knows the authoritative definition of a term because the schema marks it as authoritative. It knows which constraints apply because the structure carries that information.

The Data: 92% vs 68%

The results come from eight production deployments across Fortune 500 environments spanning manufacturing, healthcare, financial services, and professional services. Each deployment ran a controlled comparison: standard RAG (embed-chunk-retrieve) versus SCR (structured-context-retrieve), against the same underlying knowledge base, with the same LLM, measuring task completion accuracy on domain-specific reasoning tasks.

Standard RAG: 68% task completion accuracy. SCR: 92% task completion accuracy. The gap is 24 percentage points.

For enterprise applications where AI is being used to support consequential decisions — compliance interpretation, clinical reasoning, contract analysis, regulatory mapping — the difference between 68% and 92% is not an optimization. It is the difference between a system that is useful and one that is not.

What the Gap Reveals

The 24-point accuracy gap is not evenly distributed across task types. On simple lookup tasks — "what is the definition of X?" — standard RAG and SCR perform comparably. The gap widens dramatically on relational reasoning tasks: tasks that require understanding how entities relate to each other, which constraints apply under which conditions, and what the authoritative chain of reasoning looks like.

This pattern reveals something fundamental about what is broken in the standard approach. Standard RAG fails on relational tasks not because the retrieval mechanism is weak — it finds the right documents. It fails because the context it provides strips away the relational structure the model needs to reason across those documents correctly.

SCR succeeds on the same tasks because it answers a different question. Standard RAG asks: "What text is most similar to this query?" SCR asks: "What structured context does the model need to reason correctly about this domain query?" The questions sound similar. The architectural implications are completely different.

Information Sufficiency: The Right Metric

Standard RAG is typically evaluated on retrieval quality: did the system return relevant documents? SCR introduces a different evaluation frame: information sufficiency.

The Information Sufficiency Ratio (ISR) measures the proportion of schema-critical information present in the context versus required for the task. A high ISR means the context contains not just the relevant facts but the relevant structure — the entity identities, the relationship types, the constraint hierarchies that make correct reasoning possible.

In the production deployments, SCR contexts consistently achieve ISRs above 0.85 on complex reasoning tasks. Standard RAG contexts average 0.41. The accuracy gap maps almost perfectly to the ISR gap.

Production Patterns

Implementing SCR in production requires three things that standard RAG pipelines typically lack.

A semantic substrate: an explicit representation of domain entities, relationships, and constraints that can be queried structurally. This is the knowledge graph layer — not necessarily a full RDF/OWL ontology, but at minimum a typed graph where nodes are entities, edges are typed relationships, and constraints are first-class objects.

A structured retrieval layer: a query mechanism that can traverse the semantic substrate and return structured context. SPARQL, Cypher, or custom graph query — the specific technology matters less than the property that structure is preserved in the output.

A context assembly protocol: a principled method for composing structured context into a form the LLM can consume. This is where the LUBMU principle operationalizes: context must be Linked, Unambiguous, Bounded, Meaningful, and Updatable. Each dimension addresses one of the structural failure patterns in standard RAG.

Look Up First

The name of this pillar — Look Up First — encodes the discipline. Before generating an answer, look up the relevant structure. Before asserting a fact, verify it against the authoritative schema. Before reasoning, ensure the context carries enough information to reason correctly.

The 92% figure is not a claim about a specific product or algorithm. It is a claim about an architectural approach: when you look up structure first — when the context carries the known shape of the domain — AI systems reason correctly far more often.

The counter-argument to this approach is that it requires more investment upfront — a semantic substrate does not build itself. That is true. But the 68% baseline is not free either. The cost of the baseline is carried silently, in decisions made on wrong information, in compliance violations caught too late, in the AI systems that work brilliantly in demos and fail in production.

For more on why the structure crisis happens — why organizations systematically destroy the knowledge they need — see The Structure Crisis. For the next frontier question — what happens when structured AI systems must cooperate with unknown ones — see The Stranger Problem.