Research
TrustRAG: Blockchain-Enhanced RAG via Committee-Based Credibility Scoring
Modern RAG systems pull evidence from centralized databases with little oversight, so users and regulators cannot tell where a document came from, whether it was altered, or why the retriever ranked…

- arXiv
- 2608.20097
- Published
- 2026-08-20
- Authors
- Baixiang Liu, Haotian Che, Yuan Li
AI summary
Overview
Research area: Cryptography and security applied to AI infrastructure — specifically, verifiable and auditable Retrieval-Augmented Generation (RAG) built on blockchain data chains, zero-knowledge proofs, and secure multi-party computation.
Technical level: Advanced. The paper assumes familiarity with zk-SNARKs (Groth16, PLONK), Pedersen commitments, Shamir secret sharing, nullifiers, Merkle membership proofs, and MPC frameworks such as MP-SPDZ.
Scope: TrustRAG is a three-layer architecture (per-domain Data Chains, an Aggregator binding layer, and an off-chain RAG Service) that certifies documents by a committee of expert validators at registration time and lets any client cryptographically replay and verify the ranking at query time — without a recursive global aggregation proof.
What This Paper Is About
Modern RAG systems pull evidence from centralized databases with little oversight, so users and regulators cannot tell where a document came from, whether it was altered, or why the retriever ranked it highly — a serious problem in healthcare, finance, law, logistics, and news, where a manipulated or stale document directly causes bad decisions. TrustRAG's goal is to make the retrieval layer of RAG auditable end to end: expert committees score documents privately, those hidden scores are aggregated with secure multi-party computation, and the resulting per-chain credibility values are bound together with hash commitments so that any client can independently recompute the final ranking and check it against the returned evidence.
Key Contributions
-
Committee-certified knowledge base. Documents are endorsed by an expert validator committee at registration time, producing reusable trust artifacts that persist with the document's identity and are inherited by downstream retrieval, so the scoring path is not re-executed on every query.
-
Privacy-preserving multi-party trust aggregation. The zero-knowledge scoring workflow is combined with Pedersen commitments, Shamir secret sharing, and an MP-SPDZ secure-sum interface, so committee nodes aggregate hidden validator inputs without revealing individual scores or blinding factors.
-
Cross-chain binding without recursive proofs. Instead of a global aggregation proof, each chain's score digest and candidate-list digest are hashed into a per-chain digest
h_j = H(s_j || l_j), and all per-chain digests are combined into a single global digestG = H(h_1 || h_2 || ... || h_m)in canonical chain order — preventing score substitution or chain omission at lower complexity. -
Deterministic replay for ranking verification. The system publishes enough metadata (candidate sets, score hashes, list hashes, the global digest, a replay hash
r, andH(R)) for any client to independently recompute scores under the rulescore(d_i) = α · sim(Q, d_i) + β · w_i, reproduce the top-k selection, and confirm the answer is consistent with the retrieved evidence.
The authors state that, to their knowledge, this is the first decentralized RAG framework combining privacy-preserving certification, cross-chain binding, and deterministically replayable ranking in one auditable system.
Main Findings
-
Certification is moved off the query path. Documents are registered as
(docId, contentHash, embeddingHash, owner)and scored once at ingestion or score-submission time; the resulting artifacts and zero-knowledge proofs are reused across later queries rather than regenerated, so query-time work reduces to fetching finalized scores, hashing the candidate list, and replaying the ranking. -
Vote privacy is enforced by three primitives working together. Pedersen commitments (
Com_{i,t} = g^{s_{i,t}} h^{r_{i,t}} mod p) hide the score, Merkle membership againstRoot_regproves validator registration without identifying the validator, and Poseidon-based nullifiers (Null_{i,t} = Poseidon(sk_i, rid, docId_t)) detect duplicate votes in a round without revealing who voted. -
Four constraints define the scoring relation. The zk-SNARK (Groth16 or PLONK) proves membership, nullifier correctness, commitment correctness, and score range
0 ≤ s_{i,t} ≤ S_max; the chain accepts a submission only if the proof verifies againstvk_score. -
Committee aggregation uses a 4-of-3 threshold configuration. The prototype uses
n = 4committee nodes with reconstruction thresholdt = 3; the aggregated commitment is the product of individual commitments,ComTally_t^(j) = ∏_i Com_{i,t}^(j) = g^{S_t^(j)} h^{R_t^(j)} mod p, and the credibility value is normalized asw_t^(j) = S_t^(j) / (n_j · S_max)so weights stay in[0, 1]and are comparable across documents and chains. -
Global coordination is reduced to hashing and replay. The Aggregator performs no chain-local verification; it only binds each chain's finalized score hash and candidate-list hash, keeping cross-chain logic lightweight relative to recursive-proof designs.
-
Three trust assumptions are stated explicitly. Scores ≠ truth (a high score means committee endorsement, not factual correctness); completeness only relative to a declared chain set (verifiers can detect omitted chains inside
𝒥_ridbut not outside it); and detectability, not availability (tampering is publicly detectable, but the service may simply refuse to respond). -
Guarantees are explicitly bounded. The system does not guarantee factual correctness of LLM output, does not defend against prompt injection or generation-time attacks, and cannot help if a validation domain is fully compromised or if a validator simply judges poorly.
-
No experimental results are reported in the provided content. The text available here contains no evaluation section, no benchmark comparisons, no dataset sizes, no latency or throughput measurements, and no baseline results for TrustRAG itself. The only quantitative figures from other systems appear in the related-work discussion: VeriRAG is described as scaling to a 37GB dataset with a 96-second prover time and a 3-second verifier time.
Methodology in Plain English
The design splits the problem into "before the query" and "during the query."
Before any query, a document is registered on its domain's Data Chain with a content hash and embedding hash, which fixes a permanent identity. Domain experts then score it privately. Each expert publishes only a scrambled commitment to their score plus a cryptographic proof that they are a registered validator, have not already voted on this document in this round, and gave a score within the allowed range — the score value and the expert's identity stay hidden, which the authors argue prevents bribery, coercion, and retaliation. The hidden scores are then split into secret shares across committee nodes, which jointly compute the sum using secure multi-party computation (via an MP-SPDZ interface) so that no single node ever sees the individual votes. The chain checks the aggregate against the accumulated commitments and records a per-document credibility value normalized into [0, 1].
At query time, the untrusted RAG Service embeds the query, retrieves candidates from each participating chain, and hashes each exact candidate list into a list hash. It fetches the already-finalized credibility scores for those candidates, hashes them, and checks them against on-chain records. Each chain's score hash and list hash are combined into a per-chain digest, and the per-chain digests are combined into one global digest in a fixed canonical chain order — so dropping or reordering a chain is detectable. The service then ranks candidates by blending semantic similarity with credibility, passes the top documents to the LLM, and returns the answer bundled in a "ProofPack." A client verifies by checking chain-local state, checking the hash bindings, and replaying the ranking arithmetic itself — replacing a recursive proof with deterministic replay.
Why This Matters
Impact on research. The paper reframes RAG's credibility problem as a governance and provenance problem rather than a pure model-quality problem, and it offers a deliberately cheaper alternative to recursive aggregation proofs: bind with hashes, then let the verifier replay the ranking. It also connects two literatures that are usually separate — decentralized oracle/blockchain validation of data provenance (D-RAG, DeRAG, dynamic reliability scoring, VeriRAG, Proof-Carrying Answers) and privacy-preserving committee voting — and identifies a gap in the latter: prior systems largely either reveal scores in plaintext or push aggregation into an opaque backend.
Real-world applications (as named by the authors):
- Healthcare: clinical guidelines and medical literature endorsed by qualified experts before influencing diagnostic or treatment recommendations.
- Legal practice: case law and regulatory documents validated for jurisdictional relevance and currency.
- Finance: market data and disclosures traceable to a qualified source, since a stale or manipulated figure distorts trading and investment decisions.
- Logistics and traffic: continuously changing routing, capacity, and disruption information, where unverified reports propagate into downstream planning.
- News and government: expert or outlet-level endorsement of breaking coverage, and verifiable provenance for policy documents and official records to prevent citation of forged or superseded versions.
Industry relevance. The architecture targets operators who must demonstrably answer "why did the system retrieve and trust this document?" — an audit question that centralized retrieval pipelines currently cannot answer. Because it avoids recursive proving, the authors position it as substantially easier to implement than proof-heavy alternatives, which matters for organizations weighing deployment cost against compliance pressure.
Future Directions
-
Empirical validation is the obvious open item. No evaluation, benchmark comparison, dataset size, proof-generation time, verification time, or end-to-end latency for TrustRAG is reported in the available content, so the practical cost of the zero-knowledge and MPC stages relative to a centralized retriever remains unquantified.
-
Extending completeness beyond a declared chain set. The current guarantee only covers omitted or reordered chains within the agreed set
𝒥_rid; making omission detectable against chains outside that set would close a real gap, and the authors present this as an explicit limitation rather than a solved problem. -
Hardening the assumptions around scores and thresholds. Since a score reflects committee endorsement rather than truth, and since a fully compromised validation domain or a colluding honest-threshold majority defeats the guarantees, follow-on work could explore stake- or reputation-weighted committees, cross-domain auditing, or validator accountability mechanisms that make poor or captured judgment detectable.
-
Covering the generation stage. The design deliberately excludes prompt injection, generation-time attacks, and output correctness, and it offers no dedicated query-hiding protocol beyond keeping queries off-chain; extending verifiability from retrieval into generation is left open.
Target Audience
Researchers and engineers working on trustworthy or decentralized AI infrastructure — particularly those building RAG systems for regulated or high-stakes domains, and those working at the intersection of blockchains, zero-knowledge proofs, and machine learning. It is also relevant to security and compliance architects evaluating whether retrieval provenance can be made independently auditable, and to readers of the decentralized-RAG literature who want a design that trades recursive proofs for hash binding plus deterministic replay. Readers without a cryptography background will find the threat model, trust assumptions, and query-flow sections accessible, but the protocol sections require comfort with commitment schemes and MPC.
Authors’ abstract
Retrieval-Augmented Generation (RAG) lets Large Language Models (LLMs) pull in up-to-date, domain-specific information instead of relying only on what they were trained on. Yet most RAG systems still draw from centralized databases with limited oversight, making it difficult to verify where a document came from, whether it has been tampered with, or whether it should be trusted at all. This is a serious problem in domains where both the timeliness and accuracy of retrieved…
The full abstract on arXiv