TLDR
This episode introduces FlashProve, a new zero-knowledge proof system from Anthropic's red team and academic collaborators that enables verifiable inference for large language models. It allows users to cryptographically verify that a specific model produced a given output without revealing the model weights, using zkSNARKs with a two-phase offline/online design. While still a research prototype with 70-95x overhead over regular inference, it represents a massive leap over prior work and opens the door to compute governance, anti-tampering, and compliance use cases.
For you
PRO members can sign in and request more information — or their own version of this digest, tuned to what they care about.
Sign in to unlockSurprising Insights
The proof system code was largely generated by Claude and formally verified in Lean to compensate for human unauditability of AI-written optimizations.
Mixture-of-Experts architecture accidentally helps: only active experts (17B params) incur proving cost, and zero-knowledge hides which experts fired.
Batch proving after full generation (not streaming) amortizes the commitment cost, making single-GPU proving feasible.
The 70x overhead is considered a breakthrough — prior systems were thousands of times slower (e.g., ZKML GPT-2 XL: 90+ hours).
Verification is post-quantum secure (hash-based only, no elliptic curves) and runs in seconds on CPU.
Key takeaways
FlashProve uses zkSNARKs to prove that a committed model weight set produced a specific output, without revealing weights or intermediate activations.
The system splits work into a one-time offline commitment (~39 minutes) and online proof generation (~223 seconds for 24 requests on 1 H100 + 24 CPUs).
Proofs are ~19 MB and verify in ~17 seconds on CPU only — no GPU needed for verification.
Performance is 70-95x slower than standard vLLM inference, but improves over prior art (e.g., VerInf: 14.3 hours vs 223 seconds for 1024 tokens).
Formal verification in Lean proves completeness, soundness, and zero-knowledge for single-request proofs; batch zero-knowledge and GPU prover equivalence are not yet proven.
Key engineering wins: MoE sparsity (only 17B active params proven), batched post-hoc proving, single-GPU streaming via host memory, and link proofs to refresh encodings.
Limitations: integer-only model with greedy decoding, 1024-token context, architecture not hidden, side-channels unaddressed, single-GPU only, and post-hoc proofs don't prevent real-time tampering.
Notable quotes
“You paid money, picked a model name — but nobody can prove who's actually answering you in the backend.”
▸ Notable quotes · 0:11“FlashProve adopts zero-knowledge succinct non-interactive arguments of knowledge (zkSNARKs), which must satisfy two things: zero-knowledge and succinctness.”
▸ Notable quotes · 1:35“The commitment step is worth emphasizing: a one-off proof proves one run, but inference reuses the same weights millions of times — so we commit once, then prove per request.”
▸ Notable quotes · 2:54“70x sounds scary, but in 2017 SafetyNets verified a 2-layer CNN; in 2024 zkLLM did 13B LLaMA-2 at 2.5 tokens/sec; FlashProve does 400B MoE at 110 tokens/sec.”
▸ Notable quotes · 6:33“Why go through all this? Because much of this code was generated with Claude's help — AI-written complex optimizations are hard for humans to line-by-line audit.”
▸ Notable quotes · 10:02“Its weight is in 'verifiability' — speed is just the prerequisite to make it discussable. 70x is still too high for daily use, but it enters the regime where high-stakes verification becomes plausible.”
▸ Notable quotes · 14:32Chapters
0:00 — The Trust Problem in Model Serving: When talking face-to-face, identity is obvious; with API models, users cannot verify which model actually generated the response — third parties may swap models or tamper with outputs.
0:35 — FlashProve Overview and zkSNARK Primer: Anthropic's red team open-sourced FlashProve (blog, report, spec, code, Lean proofs) using zkSNARKs to prove correct execution without revealing weights, with post-quantum security via hash-based cryptography.
1:08 — Two-Phase Protocol: Offline Commitment & Online Proving: Offline: provider commits to weights once (~39 min). Online: per request, prover returns output + proof that the committed weights produced it. User verifies with commitment, input, output, proof — no weights or GPU needed.
2:09 — Cryptographic Construction: IOP, Merkle, Fiat-Shamir: Uses Interactive Oracle Proofs to reduce computation checks to few points, Merkle trees to compress proofs, and Fiat-Shamir to make non-interactive. Relies only on BLAKE2 hashes — post-quantum secure.
4:35 — Handling Non-Linearities: Lookup Arguments for Softmax/SiLU: Matrix multiplies become polynomial constraints; non-linear activations use precomputed public lookup tables — prover shows each input-output pair exists in the table.
5:57 — Benchmarks: Llama 4 Maverick (400B MoE, 4-bit quantized): Tested on 1 H100 + 24 CPUs: 223 sec for 24 requests (110 tok/s), 19 MB proofs, 17 sec verification. 70-95x slower than vLLM FP8 on 8xH100, but vastly faster than prior work (VerInf: 14.3 hrs, 93 GB proofs).
7:43 — Engineering Trade-offs: MoE Sparsity, Batched Proving, Single-GPU Streaming: Only 17B active params proven per token; batched post-hoc proving amortizes commitment; weights streamed from host RAM (232 GB) to GPU (80 GB) in chunks; link proofs refresh encodings to avoid leakage limits.
9:36 — Formal Verification in Lean: Completeness, Soundness, Zero-Knowledge: Protocol and security properties machine-checked in Lean. AI-generated prover code not yet proven equivalent; batch zero-knowledge unproven; but soundness depends only on verifier, which is verified.
11:34 — Limitations: Integer Model, Greedy Decoding, Context, Architecture Leakage, Side-Channels: Proves integer greedy decoding only — not floating-point sampling used in production. 1024-token context vs real chats. Architecture not hidden. Side-channels (timing) unaddressed. Single-GPU only.
12:26 — Post-Hoc Proofs: Detection Not Prevention; Threat Model: Proofs detect tampering after the fact — attacker could leak info before proof fails. Logs can be forged. Defense-in-depth, not a silver bullet. Re-computation adds only 1-1.5% overhead.
13:37 — Use Cases: Compute Governance, Anti-Tampering, Compliance, Audit Trails: Regulators can audit compute usage; servers can't swap models undetected; enterprises can verify safety scans; failed proofs prove effort expended; compliance binds requests to approved models.
14:30 — Trusted Hardware vs. Pure Cryptography; Anthropic's Timeline: Two paths: TEEs (trust chip) vs. ZK (trust math). FlashProve is pure software crypto. Anthropic targeted 2026-09-30 for prototype; renamed 'provable inference' to 'inference verification' — still research, not product.
Speakers
大飞 (Da Fei) — Host