Adaptive Retrieval-Augmented Generation Agents with Autonomous Evidence Verification

1. Introduction

Large language models (LLMs) have demonstrated strong fluency and broad general knowledge, but they remain prone to generating statements that are plausible in form yet unsupported or factually incorrect, a failure mode commonly referred to as hallucination [1,2]. This limitation is particularly consequential in knowledge-intensive and safety-critical domains such as technical question answering (QA), medical or legal information support, enterprise decision assistance, and autonomous agentic digital twins managing critical physical infrastructure [3,4], where unverified claims can carry severe operational and real-world costs. Retrieval-Augmented Generation (RAG) was introduced as a general mechanism for grounding generation in external, non-parametric knowledge by conditioning a generator on passages retrieved from a document index [5], building on dense retrieval methods such as Dense Passage Retrieval (DPR) [6] and earlier retrieval-augmented pretraining approaches such as REALM [7] and RETRO [8].

Despite its effectiveness, conventional RAG follows a largely static protocol: a fixed number of passages is retrieved once, prepended to the query, and passed to the generator [9]. This design has two persistent weaknesses. First, retrieval effort is not adapted to query complexity; simple factual queries and multi-hop compositional queries receive the same fixed retrieval budget, which is inefficient for the former and often insufficient for the latter [10]. Second, conventional pipelines rarely verify, before producing a final answer, whether each generated claim is actually entailed by the retrieved evidence, so an unsupported or fabricated statement can pass through the pipeline unchecked [11].

Recent work has begun to address these weaknesses individually. Self-RAG trains a model to emit reflection tokens that decide when retrieval is needed and to critique its own outputs [12]. FLARE anticipates upcoming low-confidence content during generation and triggers retrieval accordingly [10]. Corrective RAG (CRAG) introduces a lightweight retrieval evaluator that judges the quality of retrieved documents and triggers corrective actions such as web search when quality is low [13]. Self-knowledge-guided retrieval decides whether a model already knows an answer before retrieving at all [14]. Concurrently, within autonomous agent workflows, self-correcting agent architectures have demonstrated that coupling execution with iterative, closed-loop reflection significantly enhances decision reliability across complex environments [15]. These systems demonstrate that adaptive retrieval and self-assessment are individually beneficial, but most treat retrieval-triggering and answer verification as separate, loosely coupled mechanisms rather than as a single iterative decision loop that jointly reasons about evidence sufficiency and claim support.

This paper proposes AR-Verify, an agentic RAG architecture in which retrieval and verification are unified into a closed decision loop. The agent decomposes a complex query into sub-information-requirements, retrieves evidence for each sub-requirement, scores the retrieved evidence along relevance, completeness, consistency, and source-reliability dimensions, and only proceeds to answer generation once an evidence-sufficiency criterion is met or a retrieval budget is exhausted. After a draft answer is produced, a verification component decomposes the answer into atomic claims and checks each claim against the accumulated evidence pool; unsupported or contradicted claims trigger either targeted re-retrieval or claim revision before the response is finalized.

The main contributions of this paper are as follows.

• We formalize adaptive retrieval as a sequential decision process driven by an evidence-sufficiency function that combines relevance, completeness, consistency, and source-reliability signals, rather than a fixed retrieval depth.
• We introduce a claim-level verification module that scores entailment between generated claims and retrieved evidence and drives targeted re-retrieval or answer revision when support is inadequate.
• We present a unified agent architecture in which query decomposition, adaptive retrieval, and evidence verification operate as a single iterative loop rather than disjoint pipeline stages.
• We define an evaluation protocol spanning retrieval accuracy, answer correctness, faithfulness, evidence coverage, hallucination rate, and computational cost, and report representative target results that illustrate the evaluation depth expected of a completed implementation of this design.

The remainder of this paper is organized as follows. Section II reviews related work on retrieval-augmented generation, adaptive retrieval, and faithfulness verification. Section III describes the proposed methodology. Section IV details the system architecture. Section V presents the mathematical formulation and algorithms. Section VI describes the experimental setup. Section VII reports results and discussion. Section VIII provides a comparative analysis against baseline systems. Section IX discusses limitations, and Section X concludes with directions for future work.

2. Related Work

2.1. Retrieval-Augmented Generation

RAG combines a retriever, typically based on dense embeddings such as DPR [6], with a sequence-to-sequence generator conditioned on retrieved passages [5]. Fusion-in-Decoder extends this idea by encoding multiple retrieved passages independently and fusing them during decoding, improving accuracy on open-domain question answering [9]. Atlas investigates joint training of retriever and generator under few-shot settings [16], and RA-DIT proposes lightweight dual instruction tuning to better align retriever and generator objectives without full joint training [17]. REPLUG treats the language model as a black box and instead adapts the retriever using the generator’s output likelihood as a training signal, which is relevant to systems that must work with API-only LLMs [18]. Survey work characterizes RAG as a modular retrieve-augment-generate paradigm and catalogs an expanding space of augmentation strategies [19,20,21].

2.2. Adaptive and Active Retrieval

Several systems move beyond single-pass retrieval. FLARE monitors token-level generation confidence and triggers retrieval when the model is likely to produce low-confidence content, using the anticipated continuation as a query [10]. Self-RAG trains reflection tokens that decide whether retrieval is needed at all and evaluate the relevance and support of retrieved passages [12], with follow-up work examining reliability and attribution properties of such retrieval-augmented models [22]. Self-knowledge-guided retrieval first estimates whether a model already possesses sufficient parametric knowledge to answer a query before deciding whether external retrieval is warranted [14]. CRAG introduces a retrieval evaluator that assigns a confidence label to retrieved documents and triggers corrective actions, including web search augmentation and a decompose-then-recompose filtering step, when retrieval quality is judged low [13]. Prior analyses also show that irrelevant or distracting retrieved context can degrade generation quality even when some relevant evidence is present [23], and that non-parametric retrieval is not uniformly preferable to parametric memory across all question types [24], both of which motivate an explicit evidence-sufficiency judgment rather than retrieval-by-default. Furthermore, adapting retrieval dynamically over multi-step interactions inherently involves capturing evolving, intent-driven information-seeking behaviors [25]. Practical agentic systems must also balance task performance against operational resources, motivating goal-directed planning under explicit retrieval or computational budgets [26].

2.3. Faithfulness Verification and Hallucination

Hallucination in text generation has been surveyed extensively, with taxonomies distinguishing intrinsic contradictions with source content from extrinsic, unverifiable additions [1,2]. RAGTruth provides a corpus for studying hallucination specifically within retrieval-augmented settings, showing that grounding in retrieved evidence does not eliminate unsupported generation [11]. RAGAs proposes reference-free metrics for evaluating RAG pipelines along faithfulness, answer relevance, and context relevance [27]. Security-oriented work such as PoisonedRAG demonstrates that retrieval corpora themselves can be adversarially manipulated to induce incorrect generation, underscoring the importance of source-reliability signals in evidence scoring [28]. Such corpus vulnerabilities mirror broader challenges in intelligent data pipeline security, where hybrid deep learning architectures combining diverse feature extraction mechanisms are deployed to detect malicious intrusions and anomalous data streams [29]. To guarantee trustworthiness in autonomous pipelines, multi-pillar ethical and governance frameworks provide structured foundations for accountability, verification, and reliable operation [30]. In decentralized environments where knowledge spans heterogeneous, distributed repositories, secure federated agentic architectures offer mechanisms for privacy-preserving, collaborative multi-agent execution [31]. Agentic reasoning frameworks such as ReAct interleave reasoning traces with external actions [32], and Toolformer shows that language models can learn to autonomously invoke external tools, including search, when needed [33]. This paradigm is further extended by self-correcting multimodal agents that utilize autonomous feedback to diagnose and rectify operational errors [15], as well as auditable agentic digital twin frameworks that mandate verifiable and traceable reasoning steps before committing high-stakes decisions [4]. In contrast to these individual mechanisms, the present work couples an explicit multi-factor evidence-sufficiency criterion with claim-level verification inside a single agentic control loop, applied jointly at both the retrieval-decision stage and the pre-response verification stage.

3. Proposed Framework and Methodology

The proposed AR-Verify framework reframes retrieval-augmented generation as an iterative, agentic decision process with three tightly coupled stages: query decomposition, adaptive evidence acquisition, and claim-level verification. Rather than committing to a fixed retrieval depth before generation, the agent maintains an evolving evidence pool and repeatedly asks two questions: (i) is the current evidence sufficient to support a reliable answer to the current information requirement, and (ii) once a draft answer exists, is each individual claim in that answer actually entailed by the accumulated evidence. Both questions are answered by lightweight scoring functions described in Section V, and negative answers trigger corrective agent actions rather than immediate termination of the pipeline.

Given a user query q, the agent first performs query decomposition, producing a set of sub-information-requirements $\{r_1,r_2,\dots ,r_n\}$ that jointly cover the information needed to answer q. Decomposition is necessary because complex queries frequently require evidence from multiple, only partially overlapping sources, and treating the query as a single retrieval unit tends to under-serve multi-hop or comparative questions. For each requirement $r_i$, the agent selects a retrieval strategy from a small strategy set that includes dense passage retrieval, sparse lexical retrieval, and query reformulation followed by re-retrieval, choosing among them based on the estimated ambiguity and specificity of $r_i$.

After an initial retrieval pass, the agent evaluates the resulting evidence pool along four factors: relevance to the sub-requirement, completeness relative to the information the sub-requirement demands, internal consistency across retrieved passages, and estimated source reliability. These four factors are combined into a single evidence-sufficiency score, formalized in Section V. If the score falls below a decision threshold, the agent does not proceed to generation; instead it selects a corrective action, which may be an additional retrieval round with a reformulated query, retrieval from an alternative source pool, or an explicit request for evidence supporting a narrower sub-claim. This loop continues until the sufficiency threshold is met or a maximum retrieval budget is reached, at which point the agent proceeds with the best available evidence and flags the corresponding requirement as weakly supported.

Once sufficient evidence has been gathered for all sub-requirements, the generator produces a draft answer conditioned on the aggregated, deduplicated evidence pool. The verification component then decomposes the draft answer into atomic claims and, for each claim, retrieves the most relevant supporting passages from the evidence pool and computes an entailment score. Claims with high entailment scores are retained as-is; claims with low or contradictory entailment scores trigger one of three actions: targeted re-retrieval focused on the unsupported claim, claim removal when no supporting evidence can be found within budget, or claim rewriting to align the statement with the strongest available evidence. The final response is assembled from verified claims, together with optional inline indications of claims that remain weakly supported after the maximum number of verification rounds, so that downstream users retain visibility into residual uncertainty rather than having it silently discarded.

4. System Architecture

Figure 1 illustrates the overall AR-Verify architecture. The Query Decomposition module receives the user query and produces sub-information-requirements, which are routed to the Adaptive Retrieval Controller. This controller selects a retrieval strategy per requirement, invokes the Retriever against one or more Knowledge Sources, and passes retrieved passages to the Evidence Sufficiency Evaluator. If evidence is judged insufficient, control returns to the Adaptive Retrieval Controller for a further retrieval round; otherwise, evidence is added to the shared Evidence Pool. Once all requirements are satisfied or budgeted out, the Generator produces a draft answer, which is passed to the Claim Verification module together with the Evidence Pool. Unsupported claims are routed back into the retrieval loop for targeted re-retrieval, while supported claims proceed to Response Assembly, which produces the final, evidence-grounded answer.

5. Mathematical Model and Algorithms

This section formalizes the evidence-sufficiency criterion, the claim-verification score, and the overall agent control loop.

5.1. Evidence Sufficiency

For a sub-information-requirement $r_i$ and a retrieved evidence set $D_i=\{d_1,\dots ,d_k\}$, we define four component scores, each normalized to $[0,1]$: relevance $\mathrm{Rel}(r_i,D_i)$, completeness $\mathrm{Comp}(r_i,D_i)$, consistency $\mathrm{Cons}\left(D_i\right)$, and source reliability ${\mathrm{Rel}}_{src}\left(D_i\right)$. Relevance is computed as the mean embedding similarity between $r_i$ and each retrieved passage. Completeness estimates the fraction of the requirement’s inferred sub-aspects that are covered by at least one passage. Consistency measures pairwise agreement among passages on overlapping factual content, penalizing contradictory evidence. Source reliability reflects a static or learned trust score associated with each source. Analogous to multi-pillar governance frameworks designed to enforce trustworthiness, integrity, and reliability in autonomous decision-making [30], the overall evidence-sufficiency score is formalized as a weighted combination,

$$\begin{array}{cc}\hfill S(r_i,D_i)& =w_1\mathrm{Rel}(r_i,D_i)+w_2\mathrm{Comp}(r_i,D_i)\hfill \\ \hfill & +w_3\mathrm{Cons}\left(D_i\right)+w_4{\mathrm{Rel}}_{src}\left(D_i\right),\hfill \end{array}$$

(1)

where $w_1+w_2+w_3+w_4=1$ and weights are tuned on a held-out development set. Retrieval for $r_i$ terminates once $S(r_i,D_i)\ge {\tau }_s$, for a sufficiency threshold ${\tau }_s$, or once a maximum retrieval budget $B_{max}$ rounds have been exhausted.

5.2. Claim Verification

Given a draft answer y, we decompose y into atomic claims $\{c_1,\dots ,c_m\}$ using a claim-extraction step. For each claim $c_j$, we retrieve its most relevant supporting passages $D_{c_j}\subseteq {\bigcup }_i{D}_i$ from the accumulated evidence pool and compute an entailment score using a natural language inference (NLI) style scoring function $f_{ent}$,

$$V\left(c_j\right)=\underset{d\in D_{c_j}}{max}{f}_{ent}(c_j,d),$$

(2)

where $V\left(c_j\right)\in [0,1]$ approximates the probability that $c_j$ is entailed by the strongest supporting passage. A claim is accepted if $V\left(c_j\right)\ge {\tau }_v$, revised if ${\tau }_l\le V\left(c_j\right)<{\tau }_v$, and either re-retrieved or removed if $V\left(c_j\right)<{\tau }_l$, where ${\tau }_l<{\tau }_v$ are decision thresholds. The overall answer faithfulness is summarized as

$$F\left(y\right)={\displaystyle \frac{1}{m}}{\displaystyle \sum _{j=1}^m}\mathbb{1}[V\left(c_j\right)\ge {\tau }_v],$$

(3)

which is reported as the faithfulness metric in Section VII.

5.3. Agent Control Loop

Algorithm 1 summarizes the full AR-Verify control loop, combining adaptive retrieval per sub-requirement with post-generation claim verification and targeted re-retrieval.

Algorithm 1:AR-Verify Agent Control Loop

Require:  query q, sufficiency threshold ${\tau }_s$, verification thresholds ${\tau }_v,{\tau }_l$, retrieval budget $B_{max}$ Ensure:  verified response $y^{*}$ 1: $\{r_1,\dots ,r_n\}\leftarrow \mathrm{Decompose}\left(q\right)$ 2: $\mathcal{E}\leftarrow \varnothing$▹ shared evidence pool 3: for each $r_i$ do 4:     $b\leftarrow 0$ 5:     repeat 6:         $D_i\leftarrow \mathrm{Retrieve}(r_i,{\mathrm{strategy}}_i)$ 7:         compute $S(r_i,D_i)$ via Equation (1) 8:         if $S(r_i,D_i)<{\tau }_s$ then 9:            ${\mathrm{strategy}}_i\leftarrow \mathrm{SelectCorrectiveAction}(r_i,D_i)$ 10:            $b\leftarrow b+1$ 11:         end if 12:     until $S(r_i,D_i)\ge {\tau }_s$or$b\ge B_{max}$ 13:     $\mathcal{E}\leftarrow \mathcal{E}\cup D_i$ 14: end for 15: $y\leftarrow \mathrm{Generate}(q,\mathcal{E})$ 16: $\{c_1,\dots ,c_m\}\leftarrow \mathrm{ExtractClaims}\left(y\right)$ 17: for each $c_j$ do 18:     compute $V\left(c_j\right)$ via Equation (2) 19:     if $V\left(c_j\right)<{\tau }_v$ then 20:         if $V\left(c_j\right)\ge {\tau }_l$ then 21:            $c_j\leftarrow \mathrm{Revise}(c_j,\mathcal{E})$ 22:         else 23:            $D_{c_j}^{\prime }\leftarrow \mathrm{TargetedRetrieve}\left(c_j\right)$ 24:            $\mathcal{E}\leftarrow \mathcal{E}\cup D_{c_j}^{\prime }$ 25:            recompute $V\left(c_j\right)$; revise or remove $c_j$ if still unsupported 26:         end if 27:     end if 28: end for 29: $y^{*}\leftarrow \mathrm{Assemble}\left(\{c_1,\dots ,c_m\}\right)$ 30: return$y^{*}$

6. Experimental Setup

Note on scope. This paper presents the AR-Verify architecture and formulation as a research design intended for empirical evaluation. The remainder of this section describes the evaluation protocol as specified for a full implementation; Section VII reports representative target figures that illustrate the intended evaluation depth and metric behavior rather than measured results from a completed experimental run, and any eventual submission-ready version of this study must replace these with data obtained from an implemented system.

6.1. Datasets

The protocol specifies evaluation on knowledge-intensive question-answering benchmarks that require single-hop and multi-hop retrieval, following prior RAG evaluation practice [5,10,12]: an open-domain factual QA set, a multi-hop compositional QA set, a long-form generation set requiring synthesis across multiple documents, and a domain-specific technical corpus assembled for this study to test generalization beyond general-domain Wikipedia-style retrieval. Table 1 summarizes the intended dataset composition.

6.2. Implementation Details

The reference implementation specifies a dense retriever initialized from a DPR-style bi-encoder [6] over a passage index of approximately 21 million chunks, a hybrid sparse-dense retrieval fallback for the alternative-source escalation step, and an instruction-tuned LLM generator in the 7–13B parameter range for the base configuration, with a larger variant used to assess scaling behavior. The claim-verification scorer $f_{ent}$ is specified as a cross-encoder NLI model fine-tuned on evidence-claim entailment pairs. Hyperparameters for the reference configuration are listed in Table 2.

6.3. Hardware and Evaluation Metrics

The reference protocol specifies training and inference on 4×NVIDIA A100 80GB GPUs, with retriever fine-tuning performed on a single node and generation-time inference distributed across the remaining GPUs for throughput measurement. Evaluation metrics include retrieval precision and recall, answer exact-match and F1 correctness, faithfulness as defined in Equation (3), evidence coverage (fraction of gold-required facts present in the retrieved pool), hallucination rate (fraction of generated claims judged unsupported by human or automated NLI-based annotation), end-to-end latency, and average retrieval calls per query as a proxy for computational cost.

7. Results and Discussion

As noted in Section VI, the values reported in this section are representative target figures intended to illustrate the expected evaluation methodology and metric behavior for AR-Verify relative to fixed-pipeline RAG baselines; they are not measured outputs of a completed experimental run and should be replaced with real measurements before any submission claiming empirical results.

7.1. Overall Performance

Table 3 summarizes illustrative aggregate performance across the four evaluation datasets, comparing a fixed-pipeline RAG baseline, a single-mechanism adaptive baseline resembling FLARE-style confidence-triggered retrieval [10], and the full AR-Verify configuration.

The illustrative figures in Table 3 depict a pattern consistent with the design intent of AR-Verify: coupling adaptive retrieval with explicit claim verification is expected to reduce hallucination rate and improve faithfulness relative to both a fixed retrieval budget and a confidence-triggered adaptive baseline that lacks post-generation verification, at the cost of additional latency from extra retrieval and verification rounds.

7.2. Evidence Sufficiency Behavior

Figure 2 plots an illustrative relationship between the number of retrieval rounds permitted and the resulting hallucination rate, showing diminishing returns beyond three to four rounds, which motivated the reference configuration’s retrieval budget $B_{max}=4$.

7.3. Ablation Study

Table 4 reports an illustrative ablation over the four evidence-sufficiency components and the claim-verification module, indicating that removing claim verification is expected to produce the largest degradation in faithfulness, followed by removing the consistency component of the sufficiency score.

7.4. Cost and Latency Trade-off

Figure 3 illustrates the anticipated trade-off between faithfulness and average retrieval calls per query across sufficiency threshold settings ${\tau }_s\in \{0.5,0.6,0.65,0.72,0.8,0.9\}$, showing that faithfulness gains flatten while retrieval cost continues to rise beyond ${\tau }_s\approx 0.75$, informing the choice of ${\tau }_s=0.72$ in the reference configuration as a practical operating point. This behavior illustrates the fundamental trade-off between output quality and computational cost in agentic systems, mirroring observations in budget-constrained agentic planning where decision makers must optimize multi-objective criteria under finite operational allowances [26].

8. Comparative Analysis

Table 5 positions AR-Verify qualitatively against representative prior systems along the dimensions of retrieval adaptivity, verification granularity, and re-retrieval capability, based on the mechanisms described in each system’s original publication rather than a re-implementation and re-evaluation performed for this paper.

Relative to FLARE, which triggers retrieval based on token-level generation confidence [10], AR-Verify’s sufficiency score incorporates completeness and consistency signals in addition to relevance, which is intended to better capture cases where retrieved evidence is topically relevant but incomplete or internally contradictory. Relative to Self-RAG, which learns reflection tokens end-to-end [12], AR-Verify separates the sufficiency and verification judgments into explicit, interpretable scoring functions, trading some of the efficiency of a single learned model for greater transparency into why a given retrieval or revision action was taken. Relative to CRAG, which evaluates retrieval quality at the level of the retrieved document set and escalates to web search [13], AR-Verify performs verification at the level of individual generated claims, which is expected to catch a narrower category of errors, namely claims that are unsupported despite the presence of adequate evidence elsewhere in the response, that document-level evaluation would not detect.

9. Limitations

The proposed architecture has several limitations that should be considered when interpreting the design and any resulting empirical evaluation. First, the claim-verification module relies on an automated entailment scorer, and errors in this scorer propagate directly into the accept, revise, and remove decisions; a poorly calibrated $f_{ent}$ could cause the system to reject correct claims or accept unsupported ones, so the reliability of the base entailment model is a critical dependency rather than a secondary implementation detail. Second, the iterative retrieval and verification loop increases end-to-end latency and retrieval cost relative to fixed-pipeline RAG, which may be unsuitable for latency-sensitive applications without further optimization such as caching or asynchronous verification. Third, the evidence-sufficiency weights $(w_1,\dots ,w_4)$ are tuned on development data and may not transfer well across domains with different evidence characteristics, such as corpora with sparse but highly reliable sources versus corpora with abundant but noisy sources. Fourth, source-reliability scoring depends on either static trust annotations or a learned reliability model, both of which are vulnerable to distribution shift and to adversarial manipulation of retrieval corpora, as demonstrated for related RAG settings by PoisonedRAG [28]. Finally, because this paper reports a design and illustrative target evaluation rather than a completed empirical study, the actual magnitude of the reported improvements is not yet established and should be treated as a hypothesis to be tested rather than a demonstrated result.

10. Conclusions and Future Work

This paper presented AR-Verify, an adaptive Retrieval-Augmented Generation agent that unifies evidence-driven retrieval control and claim-level verification into a single closed decision loop. By formalizing evidence sufficiency as a multi-factor score over relevance, completeness, consistency, and source reliability, and by checking individual generated claims against accumulated evidence before finalizing a response, the architecture is designed to reduce unsupported claims relative to fixed-pipeline RAG and to prior single-mechanism adaptive approaches, at a moderate additional computational cost. We formalized the sufficiency and verification criteria mathematically, described a concrete agent control loop, and specified an evaluation protocol spanning retrieval accuracy, correctness, faithfulness, evidence coverage, hallucination rate, and cost. Future work includes implementing and empirically validating the full system on the specified benchmarks, exploring learned rather than fixed sufficiency weights, and integrating hybrid anomaly-detection architectures [29] to fortify source-reliability estimation against adversarial or poisoned retrieval corpora [28]. In addition, we plan to extend AR-Verify to secure federated knowledge networks [31] and explore its deployment within auditable digital twin ecosystems for smart and climate-resilient civil infrastructure [3,4], while investigating asynchronous or cached verification to reduce latency overhead and studying how calibrated verification confidence indicators can be surfaced to end users.