🤖 AI

Bayesian Uncertainty Propagation for Agentic RAG Pipelines: A Proof-of-Concept Study on Multi-Hop Question Answering

This paper proposes a Bayesian uncertainty propagation framework for Agentic RAG systems that integrates semantic divergence and self-evaluation signals to estimate system-level failure risks, demonstrating improved multi-hop reasoning reliability on HotpotQA while highlighting calibration challenges in StrategyQA.

Original authors: Louis Donaldson, Connor Walker, Koorosh Aslansefat, Yiannis Papadopoulos

Published 2026-07-02

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Louis Donaldson, Connor Walker, Koorosh Aslansefat, Yiannis Papadopoulos

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are building a team of three robots to solve a tricky puzzle. This team is called an Agentic RAG Pipeline. Here is how they work together:

The Planner: Looks at the question and breaks it down into smaller steps.
The Evaluator: Checks the information found to see if it makes sense.
The Generator: Writes the final answer based on what the other two found.

The problem is that robots (specifically Large Language Models) sometimes make mistakes or "hallucinate" (make things up), and they don't always know when they are confused. This paper asks: How can we tell if this robot team is about to give a wrong answer before they actually do?

The Solution: A "Worry Meter" for the Team

The authors created a system to measure "uncertainty" (or worry) at every step of the process. They use two main ways to measure this:

The "Confidence Check" (Token-level Entropy): Imagine the Generator robot is writing a sentence. If it is very sure, it picks the next word quickly. If it is confused, it hesitates and considers many different words. The system measures this hesitation.
The "Drift Detector" (Semantic Divergence): Imagine the Planner starts looking for information about "apples," but halfway through, it accidentally starts talking about "oranges." This system detects when the conversation has drifted away from the original goal.

The Brain: The Bayesian Network

The authors didn't just look at these worry signals individually; they connected them using a Bayesian Network. Think of this as a central control room or a traffic light system.

Each robot sends its "worry signal" to the control room.
The control room combines these signals to decide: "Is the whole team confident, or is someone panicking?"
If any part of the team is panicking (uncertain), the system flags the final answer as potentially risky.

The paper tested this on two types of puzzles:

StrategyQA: Simple puzzles that usually only need one or two steps.
HotpotQA: Complex puzzles that require jumping between many different pieces of information (multi-hop reasoning).

What They Found

1. It works best on complex puzzles (HotpotQA).
When the task is hard and requires the robots to pass information back and forth many times, the "Worry Meter" is very useful. The uncertainty from the first step adds up to the next step, and the control room can spot when the team is losing its way. In these cases, the system was better at catching errors than just looking at the final robot alone.

2. It struggles with simple puzzles (StrategyQA).
On easier tasks, the "Planner" and "Evaluator" robots often sent out false alarms (they were worried when they didn't need to be). Because the control room treated every robot's worry signal as equally important, these false alarms made the whole system think the answer was risky even when it wasn't.

The Paper's Analogy: It's like having a security system where a sensitive motion sensor in the hallway goes off every time a cat walks by, causing the whole house alarm to scream even though the front door is safe.

3. The "All-or-Nothing" Rule.
The system used a strict rule: If any robot is unsure, the whole answer is marked as "Fail." This is very safe (it rarely misses a mistake), but it can be too cautious. It might reject a correct answer just because the Planner was slightly nervous.

The Bottom Line

The paper concludes that this "Worry Meter" system is a promising tool for monitoring complex AI teams, especially when the AI has to do a lot of thinking steps. However, it needs to be smarter about who it trusts. Right now, it treats a nervous robot the same as a confident one, which can cause problems on simpler tasks.

The authors suggest that for this to work in real-world industries (like maintaining offshore wind turbines), the system needs to be tested on real industry data and tuned to ignore unreliable "worry signals" from specific parts of the team. For now, it remains a "proof-of-concept" that shows great potential but needs more polishing.

Technical Summary: Bayesian Uncertainty Propagation for Agentic RAG Pipelines

Problem Statement

The integration of Large Language Models (LLMs) into industrial workflows, such as Offshore Wind (OSW) maintenance scheduling, necessitates reliable mechanisms for estimating when multi-stage reasoning pipelines may fail. While Retrieval-Augmented Generation (RAG) and Multi-Agent Architectures (MAAs) improve interpretability by grounding responses in retrieved knowledge, they do not explicitly model how uncertainty propagates across sequential reasoning stages. In Agentic RAG systems, uncertainty introduced during planning, retrieval, or evaluation can cascade through the workflow, leading to "reasoning collapse," semantic drift, and unreliable final responses. Current black-box models offer limited insight into the reasoning behind outputs, creating a need for lightweight, runtime monitoring methods capable of quantifying confidence throughout the decision-making process.

Methodology

The authors propose an uncertainty-aware Agentic RAG framework that models the system as a sequential decision process (conceptually a Partially Observable Markov Decision Process). The methodology involves three core components:

1. Uncertainty Signal Generation

The pipeline consists of three agents: Planner, Evaluator, and Generator. Each stage produces specific uncertainty signals:

Token-level Entropy (Naive Entropy): Derived from the softmax probability distribution of generated tokens. The system calculates the log-probability of the sequence, normalizes it by length, and transforms it into a confidence feature ( $q_i$ ). This is used to parameterize prior probabilities in the Bayesian Network.
Semantic Divergence: To address "semantic drift" where an agent's search queries deviate from the original information requirement, the system measures the distance between the committed output distribution and a re-sampled output distribution in a projected embedding space. This utilizes the Wasserstein distance (analogous to the Pointwise Mutual Information in the UProp framework) to quantify Intrinsic Uncertainty (IU) at each node.
Generator Self-Evaluation ($P(True)$): The Generator agent is prompted to answer a binary question ("Are you sure that the answer provided is correct?") after producing a response. The probability assigned to the affirmative token serves as a supervised, in-context uncertainty estimate.

2. Bayesian Network (BN) Propagation

These signals are propagated through a Bayesian Network to estimate system-level uncertainty:

Structure: The workflow is modeled as a Directed Acyclic Graph (DAG) where nodes represent the Planner, Evaluator, and Generator.
Logic: The network uses a deterministic OR gate for the "Overall" node. This implies that if any single node in the pipeline is deemed a "FAIL" (uncertainty exceeds a 0.5 threshold), the overall system is flagged as "FAIL."
Inference: The BN updates posterior probabilities as new evidence (uncertainty scores) is introduced, allowing for the identification of which specific stages contribute most to system-level uncertainty.

3. Experimental Setup

The framework was evaluated as a proof-of-concept on two multi-hop question-answering benchmarks: StrategyQA and HotpotQA.

Models: GPT-3.5-Turbo and GPT-4.1-Nano.
Metrics: Performance was assessed using Area Under the Receiver Operating Characteristic Curve (AUROC) for discrimination, Area Under the Accuracy-Rejection Curve (AUARC) for selective prediction, Expected Calibration Error (ECE), and Brier Score for calibration.
Baseline: Results were compared against the UProp framework.

Key Contributions

Architecture: A lightweight monitoring architecture where Planner, Evaluator, and Generator agents produce complementary uncertainty signals (semantic divergence and self-evaluation) during multi-stage reasoning.
Propagation Model: A Bayesian Network-based model that aggregates node-level uncertainty into an interpretable system-level confidence estimate, capable of pinpointing failure points.
Empirical Evaluation: A comparative study demonstrating the strengths and limitations of Bayesian propagation across different reasoning complexities and model sizes, utilizing standard uncertainty quantification metrics.

Results

The study yielded contrasting results depending on the complexity of the benchmark:

HotpotQA (High Complexity): Bayesian propagation proved highly effective. Uncertainty accumulated across multiple reasoning stages, and the Overall BN achieved competitive or superior performance compared to individual nodes and the UProp baseline. The system demonstrated improved discrimination (AUROC) and calibration (ECE, Brier Score) as task difficulty increased.
StrategyQA (Lower Complexity): The approach showed limitations. The Generator's self-evaluation signal was the strongest individual indicator, while the Planner and Evaluator signals performed near random. Consequently, the deterministic OR gate propagated noise from unreliable upstream nodes, causing the Overall BN to underperform the Generator alone in some metrics (e.g., AUROC for GPT-3.5-Turbo).
Calibration vs. Discrimination: The deterministic OR gate introduced a conservative bias, leading to an overestimation of failure probability on StrategyQA (poor calibration) but potentially advantageous risk-aversion. On HotpotQA, calibration improved significantly, suggesting the framework is better suited for tasks where uncertainty genuinely accumulates.

Significance and Claims

The paper positions Bayesian uncertainty propagation as a promising but preliminary mechanism for monitoring Agentic RAG systems.

Core Finding: The method is most effective when uncertainty naturally accumulates across multiple reasoning stages (as seen in HotpotQA). In such scenarios, combining signals provides predictive value beyond individual node estimates.
Limitations Acknowledged: The authors explicitly note that the current framework is constrained by the deterministic OR gate, which cannot down-weight unreliable upstream nodes (e.g., the Planner on StrategyQA), and by the conservative calibration of the $P(True)$ signal.
Future Direction: The study does not claim immediate industrial deployment. Instead, it frames the work as a proof-of-concept requiring future validation in specific industrial domains, such as Offshore Wind (OSW) maintenance decision support, using domain-specific retrieval corpora rather than general-purpose benchmarks. The authors suggest that future work should focus on adaptive Bayesian structures (e.g., noisy-OR gates) and improved calibration techniques to address the identified limitations.