Pool-Gated Retrieval: Beyond Retrieval-Augmented Generation Toward Accountable Evidential Admission

Myung Ho Kim

doi:10.20944/preprints202606.0414.v1

Submitted:

03 June 2026

Posted:

04 June 2026

You are already at the latest version

Abstract

Retrieval-Augmented Generation (RAG) has become the dominant approach for grounding large language model (LLM) responses in external knowledge. Yet despite its widespread adoption, RAG suffers from a structural accountability deficit: it provides no principled mechanism for declaring what information was absent, tracking how individual passages were selected, or preventing the LLM from silently drawing on parametric knowledge when retrieval fails. This paper introduces Pool-Gated Retrieval (PGR), an architecture that addresses these deficits by enforcing three epistemically distinct stages — Horizon, Warrant, and Commitment — each with a formally specified justificatory role. In PGR, the Pool (Horizon stage) collects candidates at high recall; an LLM-driven Warrant gate evaluates each candidate through explicit function calls, applying a Result Relevance Rule and a Knowledge Gap Recognition Rule; and only warrant-approved passages are Committed as the exclusive context for answer generation. Absence is treated as a first-class epistemic fact: a Knowledge Gap is structurally registered and propagated, rather than silently papered over. We present a reference implementation as an open Python package, demonstrate the architecture on a partial-coverage retrieval scenario, and systematically compare PGR against naive RAG across eight identified failure modes. The results show that PGR eliminates absence hallucination by structural design and produces a complete, auditable provenance record for every answer.

Keywords:

retrieval-augmented generation

;

epistemic accountability

;

knowledge gap detection

;

LLM agents

;

grounded generation

;

audit trail

;

justified belief

Subject:

Computer Science and Mathematics - Artificial Intelligence and Machine Learning

I. Introduction

Retrieval-Augmented Generation, introduced by Lewis et al. [1], addresses a fundamental limitation of parametric language models: their knowledge is frozen at training time and cannot be updated without retraining. By coupling a neural retrieval component with a generative model, RAG systems can answer queries about documents that were never seen during pretraining. The approach has proven remarkably effective and has been adopted across enterprise knowledge management, customer support, legal research, and medical information systems.

The adoption has, however, outpaced scrutiny of a structural problem that is not addressable by engineering refinements to the retrieval pipeline. RAG provides no principled mechanism for three things that accountable information systems require: (1) declaring what information was sought but not found, (2) establishing a causal link between specific retrieved passages and specific claims in the generated answer, and (3) preventing the LLM from silently drawing on its parametric training knowledge when retrieval comes up empty or returns semantically adjacent but entity-mismatched passages.

These are not edge cases. In any partial-coverage knowledge base — the norm in practice — there will be entities and topics for which no document exists. A system that cannot structurally represent the absence of information will either refuse to answer (rejecting valid questions alongside unanswerable ones) or fabricate plausible-sounding content from parametric memory without disclosing it. Neither outcome is acceptable in high-stakes deployment contexts such as clinical decision support, legal research, or regulatory compliance.

Existing approaches to improving RAG — Self-RAG [2], Corrective RAG [3], HyDE [4], RAG-Fusion [5], and Modular RAG [6] — address retrieval quality through better query formulation, iterative refinement, or adaptive retrieval strategies. They improve the probability of retrieving the right passage. They do not address what happens when the right passage does not exist, nor do they provide a mechanism for auditing the justificatory basis of a generated answer.

This paper introduces Pool-Gated Retrieval (PGR), an architecture that reconceives retrieval not as a pipeline step but as a structured epistemic process. Drawing on the Horizon-Warrant-Commitment (H-W-C) framework developed in prior philosophical work on the Structured Cognitive Loop [7], PGR enforces three stages with formally distinct roles:

Horizon: a high-recall search over the document pool surfaces candidates without committing to their relevance.
Warrant: an LLM agent explicitly evaluates each candidate via structured function calls, applying a Result Relevance Rule and a Knowledge Gap Recognition Rule.
Commitment: only warrant-approved passages enter the CommitmentStore, which serves as the exclusive context for answer generation.

The central contribution is the treatment of absence as a first-class epistemic fact. When a Warrant evaluation determines that no retrieved passage addresses the queried entity or field, a Knowledge Gap is structurally registered in the CommitmentStore and propagated to the answer generation step. The final answer is obligated to report the absence rather than paper over it.

We present a reference implementation as an open Python package (pgr), demonstrate the architecture on a controlled partial-coverage scenario against a naive RAG baseline, and provide a systematic mapping from eight identified RAG failure modes to their structural resolution in PGR.

II. Related Work

A. Retrieval-Augmented Generation

The RAG paradigm [1] interleaves a dense retrieval step (typically using approximate nearest-neighbor search over vector embeddings) with a generative decoding step. The retriever encodes the query and all documents into a shared embedding space; documents with the highest cosine similarity to the query are prepended to the generator context. Subsequent work has explored learned sparse retrieval [8], hybrid dense-sparse systems, and multi-hop retrieval for compositional questions.

HyDE [4] generates a hypothetical document from the query before retrieving, improving recall for abstract or underspecified queries. RAG-Fusion [5] issues multiple query variants and merges ranked results. These approaches improve the probability of surfacing the relevant passage but do not address the structural accountability deficit: if no relevant passage exists, retrieval still returns the highest-scoring documents, and the LLM receives no signal that the retrieved set is entity-mismatched.

B. Adaptive and Corrective RAG

Self-RAG [2] trains a model to generate special reflection tokens that assess whether retrieval is necessary and whether retrieved passages are relevant. Corrective RAG [3] uses a lightweight relevance classifier to trigger a web search fallback when retrieved documents are scored as irrelevant. FLARE [9] uses the LLM’s prediction confidence to selectively retrieve additional context mid-generation.

These approaches make important progress toward retrieval awareness. However, they share a common structural limitation: relevance judgments are made by models trained on proxy signals (token log-probability, classifier scores) rather than by explicit entity and field verification. Furthermore, they do not generate an auditable record of what was retrieved, why it was accepted or rejected, and what was found to be absent. The system’s epistemic state after retrieval remains opaque.

C. RAG Evaluation

RAGAS [10] evaluates RAG pipelines along dimensions of faithfulness, answer relevance, and context precision/recall. These metrics measure the quality of the final answer and the alignment between the answer and the retrieved context. They do not measure whether the system correctly identified and reported the absence of information, nor whether the causal link between a specific passage and a specific claim in the answer can be reconstructed. PGR’s CommitmentStore is designed to make such reconstruction possible by design.

D. Epistemic Foundations

The H-W-C framework applied in PGR was developed in prior work on the Structured Cognitive Loop (SCL) [7], an agent architecture that enforces a strict separation between LLM reasoning and structural authority. The philosophical underpinning draws on Goldman’s process reliabilism [11] — the view that the epistemic status of a belief is determined by the reliability of the process that produced it, not by the subjective confidence of the believer — and on the Gettier problem [12], which established that justification and truth together are insufficient for knowledge when the justificatory process is epistemically accidental. PGR instantiates process reliabilism at the architectural level: each Committed Fact has a specified justificatory history that can be inspected independently of the answer it supports.

III. A Taxonomy of RAG Failure Modes

Before describing the PGR architecture, we systematically enumerate the failure modes of naive RAG. This taxonomy serves two purposes: it motivates the design choices in PGR, and it provides a common reference for evaluating how thoroughly each approach addresses the known failure space.

We identify eight structurally distinct failure modes, summarized in Table 1. The first four concern the retrieval stage; the next two concern context assembly; the final two are system-level properties.

Failure modes F-1 through F-4 arise from the mismatch between cosine similarity and semantic relevance. Even the highest-scoring document may pertain to a different entity (F-1), contain only half a logical unit (F-2), contribute noise at large k (F-3), or be suppressed by an overly strict threshold (F-4). Modes F-5 and F-6 arise at the context assembly stage: documents from different temporal contexts contaminate each other (F-5), and absent information is silently replaced by parametric hallucination (F-6). Modes F-7 and F-8 are structural properties of the pipeline: the absence of a causal link between passage and claim (F-7) and the absence of any accumulating record of retrieval failures (F-8).

Of these, F-6 (Absence Hallucination) and F-7 (Attribution Opacity) are the most consequential in high-stakes deployments. F-6 produces answers that are factually wrong in ways the system cannot detect; F-7 makes it impossible to audit whether a correct answer was correct for the right reasons — the distinction between knowledge and lucky guessing that Gettier identified as philosophically decisive.

IV. Pool-Gated Retrieval Architecture

A. Overview

PGR organizes retrieval as a three-stage epistemic process. Each stage has a formally specified purpose and a clearly delimited epistemic authority. The stages correspond to the Horizon, Warrant, and Commitment phases of the H-W-C framework [7].

Figure 1. Pool-Gated Retrieval architecture. Filled boxes denote active processing nodes; the dark-filled CommitmentStore is the exclusive epistemic basis for answer generation. Dashed arrows indicate data flow of uncommitted content; dashed borders indicate the Knowledge Gap path.

B. Stage 1 — Horizon (High-Recall Pool Search)

The Pool is a document store backed by a store with precomputed dense embeddings. Given a query q, the Horizon search returns all documents whose cosine similarity to the query embedding exceeds a low threshold θ_H (default 0.25), up to a maximum of N_H candidates (default 20). The purpose of this stage is breadth, not precision: it surfaces every document that might be relevant, without committing to the claim that any of them are.

Formally, let D = {d₁, …, dₙ} be the document set. The Horizon function is:

H(q) = {d∈ D : cos(e(q), e(d)) ≥ θ_H}

where e(⋅) denotes the embedding function. The Horizon provides no relevance guarantee; it guarantees only that no document above threshold θ_H has been excluded. This is the epistemic sense of ‘horizon’: the boundary of what is visible, not what is known.

C. Stage 2 — Warrant (LLM-Driven Precision Gate)

The Warrant stage is the architectural core of PGR. The LLM agent receives the question and the Horizon candidates (with content previews and similarity scores) and is equipped with three structured tools:

retrieve_knowledge(query): issue a precision search against the Pool (threshold θ_W > θ_H; top-k = 5). Returns full document content and metadata.
commit_facts(doc_ids, reason): commit one or more retrieved documents to the CommitmentStore with an explicit justification.
declare_knowledge_gap(query, reason): register a confirmed absence in the CommitmentStore with an explanation.

The Warrant loop is governed by two epistemic rules enforced in the system prompt:

Result Relevance Rule (RRR): Retrieved passages must be verified as pertaining to the specific entity and field named in the query. A high similarity score between ‘Crestwood College employment’ and a passage about ‘Crestwood College admissions’ does not satisfy the Warrant for employment data. The LLM must confirm entity and field alignment before calling commit_facts.

Knowledge Gap Recognition Rule (KGRR): One failed warrant attempt for a specific entity-field combination constitutes a confirmed Knowledge Gap. The LLM must not issue a second retrieve_knowledge call for the same entity with a rephrased query. This rule is the direct architectural response to failure mode F-6.

The Warrant loop terminates when the LLM issues no further tool calls, or when the maximum warrant call limit is reached (a structural safety bound). The stage produces a set of committed documents C ⊆ H(q) and a set of registered gaps G, with C ∪ G providing full epistemic coverage of what was known and what was absent.

D. Stage 3 — Commitment and Answer Generation

The CommitmentStore holds all Committed Facts and Knowledge Gaps accumulated during the Warrant stage. Each Committed Fact records: document content, source identifier, the Warrant query that retrieved it, the cosine similarity score, and a timestamp. Each Knowledge Gap records: the queried entity-field, the reason for rejection, and a timestamp.

Answer generation is conditioned exclusively on the CommitmentStore context. The answer generation system prompt explicitly prohibits drawing on parametric knowledge not reflected in Committed Facts. When a Knowledge Gap is present, the system prompt requires the answer to acknowledge the absence explicitly rather than omitting it.

This creates the structural property that distinguishes PGR from all existing RAG variants: the answer’s epistemic basis is fully specified before generation begins. The LLM cannot add information at generation time that was not warranted at retrieval time. This is the architectural implementation of the Grounding Principle from [7]: the epistemic basis of any reasoning episode is fixed at turn onset and does not drift.

V. Implementation

A. Package Structure

The reference implementation is provided as a Python package (pool_gated_retrieval) with no dependencies beyond openai, pandas, and numpy. The package exposes five public classes:

Pool: document store with Horizon search (cosine similarity over Pandas DataFrame) and precision retrieval. Supports save/load for persistence.
WarrantGate: implements the LLM Warrant loop using OpenAI function-calling. Enforces the KGRR by blocking repeated queries for confirmed gaps.
CommitmentStore: holds Committed Facts and Knowledge Gaps. Exposes as_context() for answer generation and summary() for inspection.
PGRAgent: orchestrates the full H→W→C pipeline and returns a PGRResult with the answer, CommitmentStore, and provenance trace.
PGRResult: encapsulates the full reasoning episode, including horizon_count, committed facts, and gaps.

B. LLM Integration

The Warrant gate uses the OpenAI Chat Completions API with tool_choice=‘auto’, providing the LLM with the three structured tools described in Section IV.C. The system is LLM-agnostic at the interface level; any model supporting OpenAI-compatible function calling can be substituted. The default model for both Warrant evaluation and answer generation is gpt-5.2.

The Warrant system prompt is the primary carrier of the RRR and KGRR rules. It specifies in precise natural language that (a) a high similarity score does not constitute a Warrant, (b) entity and field alignment must be explicitly verified, and (c) one failed retrieve_knowledge call for an entity-field pair is sufficient to confirm absence. The structural enforcement (blocking re-queries for confirmed gaps) is implemented in WarrantGate._handle_retrieve(), not in the prompt alone, providing a defense in depth against prompt-instruction non-compliance.

C. Design Decisions

The separation between the Horizon threshold (e.g., θ_H = 0.25) and the Warrant threshold (e.g., θ_W = 0.50) encodes the architectural distinction between the two stages: the Horizon must not exclude relevant documents (low threshold, high recall); the Warrant precision search must return only plausibly relevant documents (higher threshold, lower noise). The gap between θ_H and θ_W is intentional: it creates a set of candidates that pass the Horizon but fail the Warrant search, which the LLM can then explicitly declare as gaps rather than silently discarding.

VI. Experimental Evaluation

A. Setup

We evaluate PGR against a naive RAG baseline on a controlled partial-coverage scenario designed to isolate the architecturally critical failure mode F-6 (Absence Hallucination). The knowledge base contains six synthetic documents about two fictional institutions: Crestwood College (four documents covering overview, academics, employment outcomes, and facilities) and Northgate University (two documents covering overview and academics; the employment outcomes document is intentionally absent).

The evaluation query requires employment outcome data for both institutions: ‘Compare the graduate employment rates of Crestwood College and Northgate University.’ This query cannot be answered completely from the knowledge base; a correctly functioning system must both report the available Crestwood data and acknowledge the absent Northgate data.

The naive RAG baseline retrieves the top-4 documents by cosine similarity (threshold 0.10, matching standard deployment settings) and generates an answer without a Warrant stage or CommitmentStore. Both systems use the OpenAI text-embedding-3-small model for document and query embedding, and gpt-5.2 for generation.

B. Results

Table 2 summarizes the results across the metrics defined by the failure taxonomy in Section III.

C. Analysis

Both systems correctly retrieved and cited the Crestwood employment rate (88 percent). The critical divergence occurs in the handling of the absent Northgate data.

Naive RAG retrieved four documents — all from crestwood.edu — and presented them to the LLM with no signal that Northgate employment data had been sought and not found. In this evaluation, gpt-5.2 declined to fabricate a Northgate rate, noting that ‘the information provided does not include the graduate employment rate for Northgate University.’ This is a positive outcome, but it is a property of the specific model’s calibration, not of the pipeline’s architecture. A less well-calibrated model, or the same model under a more directive system prompt, would produce a fabricated rate. Critically, in no run did the naive RAG pipeline generate a structural record of the absence: no Knowledge Gap was registered, no audit trail was created, and the system state after answering is identical whether it answered correctly or incorrectly.

PGR registered the Northgate employment rate as a confirmed Knowledge Gap after one retrieve_knowledge call returned only overview and academics documents. The gap was propagated to the CommitmentStore, and the answer generation system prompt was conditioned on both the Committed Fact (Crestwood, score 0.488) and the registered gap. The final answer stated explicitly: ‘there is no available information in the current knowledge base about the graduate employment rate at Northgate University.’ This statement is structurally guaranteed by the CommitmentStore, not generated by prompt-following.

The structural contrast is most clearly expressed in the audit trail. After the PGR run, the CommitmentStore contains a complete, inspectable record: which Horizon candidates were surfaced, which Warrant queries were issued, which passages were committed (with source, score, and warrant query), and which entity-field combinations were registered as absent (with rejection reason). No equivalent record exists for the naive RAG run. This is the architectural realisation of the distinction between implicit and explicit absence: naive RAG’s answer quality is a function of LLM calibration; PGR’s answer quality is a function of structural design.

VII. Discussion

A. Limitations

The current PGR implementation has three principal limitations. First, the quality of the Warrant stage is bounded by the LLM’s ability to follow the RRR and KGRR rules; a model with weak instruction-following may commit irrelevant documents or issue redundant queries despite the structural guard. Second, the framework assumes that the Pool is the authoritative source of knowledge for the deployment context; it does not currently support hybrid retrieval from both the Pool and a web search fallback. Third, the computational cost of the Warrant loop (one or more LLM calls with function calling) is higher than a single-pass RAG retrieval; this tradeoff is acceptable for high-stakes deployments but may not be justified for low-stakes conversational applications.

B. Generalizability

Although the evaluation scenario uses synthetic data and a single query type, the architectural properties of PGR — the separation of Horizon and Warrant, the first-class treatment of Knowledge Gaps, and the CommitmentStore audit trail — are domain-independent. The same architecture applies to any retrieval setting where accountability and auditability are requirements. The Python package is designed for direct instantiation with any document corpus; the Pool class accepts arbitrary text documents and the WarrantGate’s system prompt can be extended with domain-specific relevance criteria.

C. Relation to the Structured Cognitive Loop

PGR was originally developed as the retrieval component of the Structured Cognitive Loop (SCL) [7], an agent architecture that enforces a strict separation between LLM reasoning and structural authority. The present paper extracts PGR as a standalone, independently deployable package in order to make the architecture reproducible and benchmarkable outside the full SCL framework. Three structural differences between the two implementations merit explicit clarification.

First, the scope of Commitment persistence differs in a precise way. SCL’s Memory Facts accumulate across reasoning cycles within a single turn: a fact committed in cycle 1 is structurally re-injected into the LLM context at the start of cycle 2, allowing subsequent retrieval decisions to build on prior commitments. Memory Facts do not, however, persist across turns; both SCL and standalone PGR reset their committed-fact state at turn boundaries. Standalone PGR’s CommitmentStore is per-call, which is equivalent to SCL’s per-turn scope, but lacks SCL’s intra-turn cross-cycle accumulation.

Second, and most significantly, the two implementations differ in what the LLM is permitted to see before issuing retrieve_knowledge. In standalone PGR, the LLM receives the full Horizon candidate list — with content previews and similarity scores — at the start of the Warrant loop, and uses this list to decide which queries to issue. In SCL, the Horizon (prime_turn_pool) is infrastructure that pre-populates the Pool for the turn, but its contents are never exposed to the LLM. The LLM begins its first reasoning cycle with no retrieval results and must decide what to request without knowledge of what the Pool contains. This is an epistemologically principled choice: exposing uncommitted Horizon candidates to the LLM risks contaminating its reasoning with content that has not passed the Warrant gate. Standalone PGR accepts this contamination risk in exchange for potentially reducing unnecessary retrieve_knowledge calls; SCL enforces the Grounding Principle strictly — the LLM’s epistemic state is composed exclusively of committed facts.

Third, rule enforcement depth differs. SCL enforces the KGRR and RRR through three layers: a formal regulation specification, dynamic constraint injection into the LLM context via _upsert_constraints(), and a structural call counter that injects escalating warnings when the same tool is invoked consecutively. Standalone PGR uses two layers: a Warrant system prompt and code-level gap blocking in WarrantGate._handle_retrieve(). The standalone implementation is therefore more dependent on LLM instruction-following compliance than the SCL implementation.

These differences have a direct bearing on the status of the present paper’s contribution. Standalone PGR is a minimal, reproducible reference implementation: it demonstrates that H-W-C-based RAG accountability can be achieved without the full SCL infrastructure, makes the architecture benchmarkable in isolation, and provides a clean audit trail through the CommitmentStore API. SCL-PGR is an epistemically stricter full architecture: it enforces the Grounding Principle more completely, provides three-layer structural rule enforcement, and supports intra-turn cross-cycle commitment accumulation. The two implementations are therefore not in competition. This paper’s central claim is not that standalone PGR supersedes or approximates SCL-PGR, but that the H-W-C principles are separable from the full SCL stack and can be adopted incrementally. Standalone PGR is the proof of that separability.

VIII. Conclusion

We have introduced Pool-Gated Retrieval (PGR), an architecture that reconceives retrieval-augmented generation as a three-stage epistemic process: Horizon (high-recall candidate collection), Warrant (LLM-driven relevance gate with explicit function calls), and Commitment (exclusive context for answer generation). The central innovation is the structural treatment of absence: when no relevant passage is found for a queried entity-field, PGR registers a Knowledge Gap as a first-class fact and propagates it to the answer, instead of allowing the LLM to paper over the gap with parametric hallucination.

The architecture resolves six of eight identified RAG failure modes by design, and partially addresses the remaining two. It produces a complete audit trail — Horizon candidates, Warrant decisions, Committed Facts, and Knowledge Gaps — that is independent of the final answer text and can be inspected, logged, and used for downstream accountability requirements.

A reference implementation is provided as an open Python package. We release it as a foundation for future work on accountable retrieval systems, including multi-turn CommitmentStore accumulation, hybrid Pool-plus-web retrieval, and formal evaluation of the Warrant gate’s precision under varied LLM backbones.

References

P. Lewis et al., “Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks,” Advances in Neural Information Processing Systems (NeurIPS), vol. 33, pp. 9459–9474, 2020.
A. Asai, Z. Wu, Y. Wang, A. Sil, and H. Hajishirzi, “Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection,” in Proc. International Conference on Learning Representations (ICLR), 2024.
S.-Y. Yan, Q. Gu, Y. Zhu, and Z. Ling, “Corrective Retrieval Augmented Generation,” arXiv preprint arXiv:2401.15884, 2024.
L. Gao, X. Ma, J. Lin, and J. Callan, “Precise Zero-Shot Dense Retrieval without Relevance Labels,” in Proc. Annual Meeting of the Association for Computational Linguistics (ACL), pp. 1762–1777, 2023.
A. Raudaschl, “RAG-Fusion: A New Take on Retrieval-Augmented Generation,” arXiv preprint arXiv:2402.03367, 2024.
Y. Gao et al., “Retrieval-Augmented Generation for Large Language Models: A Survey,” arXiv preprint arXiv:2312.10997, 2023.
M. H. Kim, “Epistemic Architecture of Accountable Artificial Agents: Justified Acceptance Paths and the Horizon-Warrant-Commitment Framework,” PhilSci Archive 29762, 2026.
K. Formal, C. Piwowarski, B. Piwowarski, and S. Clinchant, “SPLADE: Sparse Lexical and Expansion Model for First Stage Ranking,” in Proc. ACM SIGIR, pp. 2288–2292, 2021.
Z. Jiang, F. F. Xu, L. Gao, Z. Sun, Q. Liu, J. Dwivedi-Yu, Y. Yang, J. Callan, and G. Neubig, “Active Retrieval Augmented Generation,” in Proc. EMNLP, pp. 7969–7992, 2023.
S. Es, J. James, L. Espinosa-Anke, and S. Schockaert, “RAGAS: Automated Evaluation of Retrieval Augmented Generation,” in Proc. EACL (System Demonstrations), pp. 150–158, 2024.
A. I. Goldman, “What Is Justified Belief?,” in G. S. Pappas (Ed.), Justification and Knowledge. D. Reidel, pp. 1–23, 1979.
E. L. Gettier, “Is Justified True Belief Knowledge?,” Analysis, vol. 23, no. 6, pp. 121–123, 1963.

Table 1. RAG Failure Mode Taxonomy.

ID	Failure Mode	Description
F-1	Similarity ≠ Relevance	High cosine score does not imply semantic relevance; topic-adjacent passages are injected without entity verification.
F-2	Chunk Boundary Truncation	Fixed-size chunking severs logical units (cause–effect, conditional) across chunk boundaries.
F-3	Over-retrieval	Large top-k injects noisy or contradictory passages, increasing hallucination risk.
F-4	Under-retrieval	Strict thresholds or small top-k silently omit necessary passages; the system proceeds without them.
F-5	Context Contamination	Passages from different time periods, sources, or entities co-occur in a single context window.
F-6	Absence Hallucination	When no passage exists for a queried entity, the LLM silently draws on parametric knowledge without disclosure.
F-7	Attribution Opacity	No causal link exists between a generated sentence and the specific passage that warranted it.
F-8	No Feedback Loop	Retrieval failures are not recorded; the system cannot adapt within or across turns.

Table 2. Experimental results on partial-coverage retrieval scenario.

Metric	Naive RAG	PGR (ours)	Notes
Correct Crestwood fact cited	Yes	Yes	Both systems cite 88%
Northgate employment figure fabricated	No*	No	*gpt-5.2 declined; weaker models fabricate
Absence structurally declared	No	Yes	KG registered in CommitmentStore
Audit trail (source + query + score)	No	Yes	Full H→W→C provenance logged
Committed facts	—	1	crestwood.edu/outcomes (score 0.488)
Knowledge gaps registered	0	1	Northgate employment rate
Retrieve calls (Warrant loop)	—	2	Crestwood + Northgate; loop terminated

Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

© 2026 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).

Copyright: This open access article is published under a Creative Commons CC BY 4.0 license, which permit the free download, distribution, and reuse, provided that the author and preprint are cited in any reuse.