Audited Credibility for Hallucination Checkers

Most systems that catch LLM hallucinations are pipelines. They split a generated answer into small claims, send each claim to one or more checkers (a retrieval lookup, an entailment model, a resampling consistency test, an LLM judge), and then flag or rewrite the claims that fail. These pipelines treat every checker as equally trustworthy on every claim, and forever. In practice a checker's reliability depends on the claim. A Wikipedia lookup is strong on famous people and weak on obscure ones. A self-consistency test is confidently wrong on common misconceptions the model holds firmly. Any checker can silently get worse when its retrieval index goes stale or its backbone model is swapped. We propose to give each checker a running credibility score, kept separately for each kind of claim and updated online from a small, budgeted stream of audits. That score decides both which checkers to call and how much to believe each one.

Put in two sentences: treat the checkers inside a modular hallucination pipeline as information sources whose track record is learned online, per claim type, from occasional expensive audits. The result should be a pipeline that detects more hallucinations per unit of compute than static ensembles and that notices within a few dozen audits when one of its own components breaks.

Core Claim

Dynamic credibility assignment means scoring an information source's reliability as a quantity that changes over time with its verified performance, rather than as a fixed prior. The literature has applied it to three kinds of source. SecureCollaRAG scores retrieved documents and their providers with a graph neural network to resist poisoned passages. CrS scores whole answering agents with outcome rewards and Shapley-value credit. Credibility Governance scores agents in a simulated society under weak truth signals. None of them scores the verification modules of a hallucination pipeline. None conditions credibility on the type of claim being checked. None treats audit labels as a scarce resource to spend.

On the modular side, PFME decouples retrieval, error typing, and editing. HaDeMiF attaches small trained detector heads to a frozen model. A-MAC combines five interpretable signals through a linear rule learned offline. All three are memoryless at test time. A-MAC shows the cost: its F1 drops from 0.482 on personal conversations to 0.338 on professional ones, which is exactly the shift a fixed weighting cannot follow.

Our claim is that checker reliability is strongly stratified by observable claim properties. FActScore motivates this: it documents precision collapsing on rare entities and decaying later in a generation. Given that stratification, an audit-anchored credibility state, indexed by checker and claim stratum and updated asymmetrically, beats both fixed ensembles and label-free consensus. It should win at equal compute under distribution shift, and it should win decisively when checkers make correlated errors.

Research Program

We will build a pipeline with a uniform checker interface. Every checker takes a claim and optional context and returns a verdict with a confidence. Retrieval, entailment, consistency, and judge modules can then be swapped without touching the credibility engine. This interface is the design lesson of the Universal Causal Evaluation Engine, which isolates data generation from estimators behind one API. Here it plays a second role: it lets us inject controlled component failures.

Claims are bucketed into strata by cheap features: entity popularity (for example, page-view or link-count buckets), relation type, position in the generation, and source task. For checker $m$ in stratum $s$ we keep a Beta-style credibility state with counts $a_{m,s}$ (audited correct verdicts) and $b_{m,s}$ (audited wrong ones). Each audited verdict triggers the update

$$a_{m,s} \leftarrow \lambda a_{m,s} + \mathbb{1}[\text{correct}], \qquad b_{m,s} \leftarrow \lambda b_{m,s} + \kappa\,\mathbb{1}[\text{wrong}],$$

where $\lambda \in (0,1]$ is a forgetting factor that lets old evidence fade, and $\kappa > 1$ makes errors cost more than successes earn. The asymmetry follows the observed fast-loss, slow-gain dynamics of user credibility; Mutual Influence of Users Credibility and News Spreading in Online Social Networks and guards against the build-trust-then-fail pattern that Credibility Governance flags as its main weakness. Unaudited strata back off to the pooled estimate for that checker.

A claim's final hallucination score combines checker verdicts $v_m \in \{-1,+1\}$ as

$$z = \sum_m v_m \log \frac{\hat r_{m,s}}{1-\hat r_{m,s}},$$

with $\hat r_{m,s} = a_{m,s}/(a_{m,s}+b_{m,s})$. This is the standard weighted-vote form for independent sources of known accuracy.

The same estimates drive routing. Checkers are called in increasing cost order, and calling stops once $|z|$ clears a threshold. Audits are spent where the posterior over $\hat r_{m,s}$ is widest. The audit oracle is the FActScore retrieve-plus-model-plus-nonparametric estimator, which the FActScore paper reports disagrees with human experts by under 2% in error rate, or human or gold labels where the benchmark provides them.

Two constraints shape the design. Per HaluEval, judging candidates side by side hurts LLM evaluators, so every checker sees one claim in isolation. Per PFME, retrieval checkers use 4 to 7 evidence chunks.

Baselines

The naive reference point is the generator judging its own output. HaluEval reports ChatGPT self-detection accuracy of 62.59% on QA, 72.40% on dialogue, and 58.53% on summarization, with open-source models near or below 50%. We will run the same self-check with our open backbones.

The strongest existing method is PFME run in full on every claim. On FavaBench it reports a detection gain of +8.7 percentage points (PFME with Llama3-8B over a ChatGPT baseline) at 3.31 seconds per sample. On FActScore it reports gains of +16.2 points for Alpaca 13B and +4.6 points for ChatGPT after editing. We reproduce PFME on the same generations with the same retrieval backend. Our system counts as beating it if it matches PFME's detection F1 at no more than half its checker-seconds per claim, or exceeds it by a clear margin at equal cost. The margin is the bootstrap confidence interval over claims.

The second strong competitor is a static stacked ensemble. It is a logistic combiner over the same checkers, conditioned on the same strata features, and fit offline on exactly as many audit labels as our online system consumes over the stream, in the spirit of A-MAC's learned linear policy. It gets the same hyperparameter search budget as our $\lambda$, $\kappa$, and threshold.

The third is label-free truth discovery: Dawid-Skene-style reliability estimation over checker agreements, the consensus idea behind truth discovery from crowdsourced streams and consensual opinion pooling. Plain majority vote across checkers is included as its degenerate form.

Where the backbone is open, we add HaDeMiF as a white-box detector, whose reported headline is up to 51% ECE reduction on the CAT benchmark. We also include DoLa as a generation-side reference. On TruthfulQA, DoLa reports 17 absolute points for LLaMA-7B and over 12 for LLaMA-65B.

Ablations isolate each ingredient. A single scalar credibility per checker, which is effectively CrS's per-agent score, isolates stratification. Setting $\kappa=1$ isolates asymmetry. Setting $\lambda=1$ isolates forgetting. Calling every checker every time isolates routing. Spending audits uniformly at random isolates targeted auditing.

Why not just…?

Why not just always run the strongest verifier? If one checker dominates in every stratum and is cheap, this wins and our routing is pointless. We will report the per-stratum accuracy matrix first. The FActScore rarity effect predicts that retrieval checkers fail on rare entities while resampling-based checkers fail on common misconceptions, the inverse-scaling pattern from TruthfulQA. If no crossover shows up, we will say so and fall back to the cheaper question of detecting when that one verifier degrades.

Why not just fit a static ensemble offline? Under a stationary stream, a stacked ensemble trained on the same labels should match us, and we expect it to. The proposal only claims an advantage under shift and component change. The domain-ordered stream and the component-swap experiment below are designed to show whether that advantage exists. If the static ensemble refit every $k$ audits closes the gap, the contribution shrinks to auditing policy, and we will report it that way.

Why not just estimate checker reliability without labels, from agreement? Agreement-based estimation is the real threat because it needs no audit budget at all. It fails when checkers share blind spots. Two model-based checkers built on similar pretraining data will agree on the same misconception, and consensus will then certify the error. That is the collective drift the credibility literature warns about. We test this directly on the correlated-error slice. If Dawid-Skene matches us there too, audits are not worth their cost.

Why not just use a bigger generator or contrastive decoding? TruthfulQA shows larger models can be less truthful on misconceptions. DoLa can only surface facts the model already learned, and it needs white-box access. Both change the generator rather than the checking. We report them as complementary references, not substitutes.

Proposed Experiments

The main stream orders claims from FActScore biographies (frequent entities first, then rare), then FavaBench, then HaluEval QA, dialogue, and summarization. This produces two known shifts. We plot claim-level detection F1 and AUROC against cumulative checker-seconds and audits spent, and report ECE on the CAT splits for comparison with HaDeMiF. Downstream, we feed flagged claims to a PFME-style editor and report the FActScore of the edited biographies.

The first decisive check is a silent regression. Midway through the stream, the modular interface lets us replace the retrieval checker's index with a stale snapshot, or swap its backbone for a weaker model. We measure how many audits each method needs before that checker's weight falls, and how much detection F1 is lost in the meantime. The asymmetric updates should cut this recovery time relative to the static ensemble, the symmetric ablation, and consensus estimation.

The second decisive check is the correlated-error slice. On TruthfulQA misconception questions and rare-entity FActScore claims, we hold out the checkers that share a failure mode and ask whether audit-anchored credibility still down-weights them while agreement-based methods do not.

The last check is honesty about the audit oracle. We re-score a random subset with human labels to confirm that the FActScore estimator's under-2% error holds on our claim mix. Oracle errors bias every method that uses audits, and they must not be mistaken for a checker's weakness.