Self-Verbalized UQ: Transparent AI Confidence

• Self-verbalized UQ is a method where AI agents report explicit confidence values and natural language explanations alongside their decisions.
• It leverages supervised fine-tuning, chain-of-thought transfer, and reinforcement learning from human feedback to calibrate uncertainty effectively.
• This approach enhances transparency and agentic control, enabling applications in chatbots, robotics, and decision support where explicit uncertainty is key.

Self-verbalized uncertainty quantification (UQ) refers to methods by which an AI agent or LLM reports, in natural language, its own intrinsic confidence and rationale regarding its outputs. Instead of relying solely on implicit token-level certainty (e.g., log-probabilities), these approaches require the agent to articulate scalar confidence values and semantic explanations contemporaneously with each decision or prediction. This paradigm not only renders the agent’s internal state transparent to users but enables the construction of downstream workflows that actively and adaptively leverage self-estimated uncertainty in inference and control. Self-verbalized UQ explicitly bridges the gap between algorithmic confidence assessment and interpretable, actionable metacognition, serving roles in everything from calibration diagnostics to agentic control policies (Zhang et al., 22 Jan 2026, Shorinwa et al., 2024).

1. Conceptual Foundations and Taxonomy

Uncertainty quantification for LLMs and agents encompasses methods that provide explicit estimates of prediction reliability for a given prompt or trajectory. A recent taxonomy (Shorinwa et al., 2024) partitions these techniques into four principal categories:

1. Token-level methods (log-probs, entropy, token margins).
2. Self-verbalized uncertainty quantification methods.
3. Semantic-similarity-based uncertainty quantification.
4. Mechanistic interpretability approaches.

Self-verbalized UQ is characterized by the requirement that the model outputs explicit confidence quantification—usually as a probability or discrete label (e.g., high/medium/low)—and often a natural-language explanation describing uncertainty sources. This explicitness contrasts with approaches that estimate confidence via model internals or output distributions.

In agentic reasoning frameworks, self-verbalized UQ extends beyond passive reporting: at each reasoning-action step $t$, the agent outputs not only the chosen action $a_t$, but also a scalar confidence $\hat c_t \in [0,1]$ and a verbal explanation $\hat e_t$ capturing epistemic self-assessment (Zhang et al., 22 Jan 2026).

2. Methods and Architectural Implementations

Self-verbalized UQ techniques follow three primary methodological archetypes for LLMs and agents (Shorinwa et al., 2024):

• Supervised Fine-Tuning on Calibrated Data: An LLM is fine-tuned to emit answers alongside calibrated probabilistic or ordinal confidence statements, using datasets where correctness can be externally verified (e.g., CalibratedMath, Mielke et al.). The verbalized confidence is mapped either numerically (“I am 78% confident”) or categorically.
• Distillation and Chain-of-Thought Transfer: Teacher models generate both chain-of-thought rationales and explicit confidence scores. Student models are then trained to imitate this output pair, aligning generation with confidence estimation (e.g., LACIE framework, Yang et al.).
• Reinforcement Learning from Human or Self-Reflective Feedback: RLHF is employed to penalize disparity between verbalized confidence and ground-truth correctness, thereby incentivizing better calibration. Self-reflective protocols further allow the model to revise and self-assess prior outputs (SaySelf, Tao et al.).

In the agentic context, the Dual-Process Agentic UQ (AUQ) architecture (Zhang et al., 22 Jan 2026) operationalizes self-verbalized UQ as an active, bidirectional control signal. The AUQ comprises two complementary systems:

System 1 (Uncertainty-Aware Memory, UAM):

• At each step, the elicitation mapping $\Phi: h_t \mapsto (a_t, \hat c_t, \hat e_t)$ produces the candidate action, confidence, and explanation from the agent’s trajectory history $h_t$.
• Memory $$\mathcal M_t = {(o_i, a_i, \hat c_i, \hat e_i)}_{i=0}^{t-1}$$ accumulates step-wise epistemic assessments.
• Forward uncertainty is recursively propagated via $P(V_t = 1|h_t) = c_t \cdot P(V_{t-1}=1|h_{t-1})$, with explanations $\hat e_i$ preserved for attention-based modulation of future actions.

System 2 (Uncertainty-Aware Reflection, UAR):

• A switching function $S(h_t)$ triggers reflection when $\hat c_t < \tau$ ($\tau$ is a reliability threshold), activating an inverse policy $\pi_{\text{inv}}$ that resamples candidate actions and confidences conditionally on the memory and explanation.
• Actions are selected by maximizing consistency-weighted confidence: $$S_{\text{cons}}(a) = \frac{1}{N} \sum_{k=1}^N \hat c^{(k)} \cdot I[a^{(k)} \equiv a]$$.
• If consensus confidence remains low, the memory context is adaptively expanded for deliberative re-evaluation.

3. Algorithmic Workflow

The generic workflow for self-verbalized agentic UQ at each step $t$ (as in AUQ) proceeds as follows (Zhang et al., 22 Jan 2026):

1. System 1 infers $$(a_{\text{init}}, \hat c_{\text{init}}, \hat e_{\text{init}})$$ from the current history and memory.
2. If $\hat c_{\text{init}} \geq \tau$, the action is accepted; if not, System 2 is invoked:
   • A reflection prompt is built incorporating the current explanation.
   • Multiple candidates $(a^{(k)}, \hat c^{(k)})$ are sampled via $\pi_{\text{inv}}$.
   • The action maximizing $S_{\text{cons}}(a)$ is chosen as $a_t$.
3. The environment is advanced with $a_t$ and new observation $o_{t+1}$ is appended to memory.
4. The tuple $(o_t, a_t, \hat c_t, \hat e_t)$ is added to $\mathcal M$.

The dual-process policy is defined by:

$$\pi_{\text{dual}}(a|h_t) = \begin{cases} \pi_{\text{fwd}}(a|h_t, \mathcal M_t) & \text{if } S(h_t)=0 \ \pi_{\text{inv}}(a|h_t) & \text{if } S(h_t)=1 \end{cases}$$

4. Calibration Metrics and Evaluation Paradigms

Assessment of self-verbalized UQ leverages both standard and trajectory-level calibration metrics (Shorinwa et al., 2024, Zhang et al., 22 Jan 2026):

Pointwise Metrics:

• Expected Calibration Error (ECE):

$$\text{ECE} = \sum_{m=1}^M \frac{|B_m|}{n} \left| \text{acc}(B_m) - \text{conf}(B_m) \right|$$

where $B_m$ are bins of predictions grouped by confidence.

• Maximum Calibration Error (MCE):

$$\text{MCE} = \max_{m=1,\ldots,M} \left| \text{acc}(B_m) - \text{conf}(B_m) \right|$$

• Cross-Entropy Loss and Brier Score for probabilistic calibration.

Trajectory-Level Metrics (Agentic Setting):

• Aggregated Confidence over a trajectory $c_{1:T}$:
  • End-State: $C = c_T$
  • Overall Average: $C = (1/T)\sum_{t} c_t$
  • Process Minimum: $C = \min_t c_t$
• Trajectory-ECE (T-ECE):

$$T\text{-ECE}_\Phi = \sum_{m=1}^M \frac{|B_m|}{N} \left| \text{acc}(B_m) - \text{conf}(B_m) \right|$$

• Trajectory Brier Score (T-BS):

$$T\text{-BS}_\Phi = \frac{1}{N} \sum_{i=1}^N \left( C^{(i)} - Y^{(i)} \right)^2$$

• Trajectory-level AUROC, treating $C$ as classifier score for binary success labels.

5. Experimental Results and Empirical Findings

Self-verbalized UQ methods have been validated across benchmark LLM and embodied agent environments. In agentic settings, the Dual-Process AUQ demonstrated superior calibration and performance relative to ReAct, CoT-SC, and ablated baselines (Zhang et al., 22 Jan 2026). Highlights include:

Dataset	Method	$\Phi_{\text{last}}$ ECE	Success Rate	AUROC ($\Phi_{\text{last}}$)
ALFWorld	ReAct	0.306	63.6%	0.913
	CoT-SC	0.185	69.5%	0.948
	Inverse-Only	0.205	72.9%	0.958
	Dual-Process	0.174	74.3%	0.968
WebShop	ReAct	—	29.3%	0.863
	Dual-Process	—	42.9%	0.888

On open-ended tasks (DeepResearch), the Gemini-2.5-Pro and GPT-5.1 variants of AUQ outperformed enterprise baselines in RACE score (Gemini-2.5-Pro: 51.97, GPT-5.1: 52.09, baseline: 50.62).

LLM-focused studies note that supervised and RL-finetuned verbal confidence can become over-clustered (e.g., 80–100% in 5% increments), show domain-dependent calibration, and are sensitive to prompt wording and verbalization style (Shorinwa et al., 2024).

6. Strengths, Limitations, and Design Considerations

Strengths:

• Direct interpretability: Natural-language confidence and rationale facilitate human comprehension and decision-making, especially in interactive or high-assurance systems.
• Agentic control: Verbalized uncertainty acts as an internal control signal to toggle between rapid action and deliberative correction (dual-process policy).
• Integrates with conversational UIs, enabling users to probe sources of uncertainty in situ.

Limitations:

• Calibration sensitivity: Verbalized confidence tends to be over-confident; outputs are shaped by training domain, template regularization, and linguistic norms.
• OOD generalization remains weak relative to token-based metrics.
• Small models ($<7$B parameters) often fail to produce reliably calibrated confidence scores or nuanced explanations (Zhang et al., 22 Jan 2026).
• Reflection routines (slow path) introduce additional inference latency, which may be unsuitable for latency-critical domains.
• Static thresholds for reflection do not adapt to local risk, motivating future work on learned, dynamic risk budgets.

Empirical comparisons suggest that pointwise, token-based UQ often yields lower calibration error; however, self-verbalized UQ enhances practical trust and enables agentic introspection workflows not accessible to purely implicit confidence methods (Shorinwa et al., 2024).

7. Application Domains and Future Research Directions

Self-verbalized UQ has found application in:

• Chatbots and virtual assistants, where user trust depends on explicit cues for uncertainty.
• Safety-critical automation in robotics and aviation, as a trigger for human override or automatic fail-safes.
• Educational and tutoring systems, where verbalizing uncertainty supports robust pedagogy.
• Decision support in medicine and law, where practitioners weigh model suggestions by direct inspection of confidence.

Key open research challenges include:

• Achieving robust calibration across diverse domains and tasks.
• Engineering architectures (e.g., confidence heads, explicit reasoning modules) that stabilize and standardize self-verbalization.
• Developing standardized, multi-task benchmarks with ground-truth confidence labels.
• Incorporating mechanistic interpretability and internal probes to ground verbal confidence in model internals.
• Studying human–AI interaction patterns to close the loop between stated uncertainty and actual user trust or action.

A plausible implication is that the continued development of self-verbalized UQ, particularly as a bi-directional control signal, will underpin advances in reliable, collaborative, and transparent AI agents, enabling both more trustworthy interactive applications and more resilient autonomous systems (Zhang et al., 22 Jan 2026, Shorinwa et al., 2024).