A user who sends a prompt to a model provider cannot check which model produced the reply: the weights are secret, and rerunning a frontier model is beyond almost any user's means. The post "Progress on provable inference for large language models", published on 2 November 2026 under Anthropic's Frontier Red Team, describes FlashProve, a system in which the provider commits to a model's weights and then produces a proof, for a given prompt, that the committed weights produce the claimed output, without revealing the weights. The post (about 4,900 words) is the motivation; the version of record for the system is the technical report "FlashProve: an open-source library for provable inference" (23 pages, dated November 2026) and the code, Lean proofs and documentation in the FlashProve repository, released under Apache 2.0 at commit 9e2bdd8 (30 October 2026, version 0.16.0), which describes itself as "A research artifact: not maintained". The authors are Roy Rinberg and Alex Allain (Anthropic), Alessandro Chiesa (EPFL, StarkWare), Miranda Christ (MIT, RESI), Rahul Dalal (Anthropic STEM Fellows Program, Succinct), Giacomo Fenzi (EPFL), Ben Mayer (Anthropic Fellows Program, MIT) and Guy Weissenberg (EPFL). The post calls itself a share of "intermediate progress, and not a completed research agenda". The page's metadata records a modification on 9 November 2026 without a visible note of what changed; this note follows the copy read on 13 November 2026.
Terms
- Provable inference (PI): letting a user with modest computing power, and no access to the weights, check that a response came from a specified model.
- zkSNARK (zero-knowledge succinct argument of knowledge): a proof system in which a prover convinces a verifier that a computation was done correctly by sending a short certificate. Completeness means an honest proof is accepted; soundness means a false statement is accepted only with negligible probability; zero knowledge means the proof reveals nothing beyond the statement; succinctness means the proof is small and much cheaper to check than the computation.
- Commitment: a short fingerprint that binds the provider to one exact set of weights while keeping them hidden.
- Interactive oracle proof (IOP): the information-theoretic protocol at the core of the system, turned into a single-message proof using hash trees and the Fiat–Shamir transformation (report, Section 3).
- Random oracle model (ROM): an idealized setting, used in the security proofs, in which the hash function (here BLAKE2) is treated as a truly random function (report, Section 2).
- Lean: a proof assistant in which mathematical statements and their proofs are checked by machine.
- Mixture of experts (MoE): an architecture in which each layer routes a token to a few of many expert sub-networks, so only part of the model runs per token.
Why the authors want it
The post lists four uses for proofs of inference ("Trust challenges in AI proliferation"). They are proposals; none is tested in the release.
- Pacing. A regulator could require certificates showing that a provider's hardware served a claimed model, as a check on proposals that limit how compute is used. The post notes that this "does not establish that the hardware is not, e.g., training on the side."
- Tamper detection. A provider could require a valid proof for every response, so that an attacker who compromises an inference server, or a model that substitutes itself for another, would be detected.
- Text provenance. A provider could attach a proof that a given model produced an output, for instance to show that code was scanned by a particular model.
- Model approval. A regulator could require proofs that only approved models are served.
The post also connects the work to Anthropic's Frontier Safety Roadmap, which set a goal of a provable-inference prototype by 30 September 2026. It says that goal was met by "a separate but related project", which signs inference traffic and recomputes inference on a trusted server, and that an update of 19 October 2026 renamed the goal "inference verification" because "provable inference" suggested a narrower approach than needed (footnote 3). FlashProve pursues the same aim by a different, software-only method. The post contrasts this with trusted hardware, which relies on the manufacturer's tamper resistance, and calls the two "complementary".
What FlashProve does
The system has two phases (post, "Our system: FlashProve"; report, Sections 1 and 5). Offline, the provider encodes the weights with random masks and publishes a commitment. Online, for each request, the provider produces a proof file stating that the committed model, given the prompt, produces the claimed token. Anyone with the commitment, the prompt and the reply can check it.
The construction is described in the report as "a bespoke composition of state-of-the-art building blocks" from the zkSNARK and zkML literatures, and it "does not claim to be a paradigm shift" (Section 5). Choices the report highlights:
- The prover's work follows the experts that ran. In Llama 4 Maverick, one of 128 experts plus a shared expert runs per MoE layer, so a token uses about 17 billion of 400 billion weights. The trace records only the experts used, and the proof hides which ones (Section 5.2).
- Integer arithmetic. The proof concerns an exact integer-quantized version of the weights, since proof systems work over finite fields and floating-point results do not reproduce across machines (Section 5.2, Section 7). A footnote states that this quantized model "says nothing about how inference is implemented in production at Anthropic or elsewhere" (footnote 5).
- Lookups handle nonlinear functions such as softmax and SiLU through public tables of 2^16 inputs (Section 5.2).
- Batching after the fact. Requests are proved in batches after the response has been served, reading the finished text in one parallel pass, as in prefill. This is post-hoc proving, as opposed to proving alongside generation (post, "Post-hoc versus in-line"; report, Appendix).
- Link proofs let one commitment serve many requests without wearing out the hiding of the weights (Section 5.4). The post says a commitment is good for "about 16 million requests"; the report does not give that number, and the repository's weight-hiding guide instead states a limit of 688,127 batches per encoding. At the measured 24 requests per batch, 688,127 batches come to about 16.5 million requests, which may be the source of the post's figure (our arithmetic and inference; neither document makes the link).
What it measures
All measurements are on Llama 4 Maverick in a third party's public 4-bit conversion, with 1,024-token requests, targeting 128 bits of security (report, Section 6). The repository's performance guide gives the conditions: three timed runs, on three machines at the same hours of one day, reported as mean and sample standard deviation. Three runs elsewhere on another day gave 105.3 ± 3.9 tokens per second at 24 requests per batch, and the guide states that the runs' records are not in the repository, "so a reader cannot check the figures on this page against them".
- Prover. One H100 (80 GB) and 24 CPU cores, with the 232 GB of weights in host memory and streamed to the GPU. The offline phase takes about 39 minutes, and the provider stores 2.15 GB. A batch of 24 requests takes about 223 seconds, which the report states as 110 tokens per second (111.23 ± 0.92 in the performance guide); each proof is 18.78 MB.
- What a "token" counts. The rate counts every one of the 1,024 prompt tokens the prover processes, "even though the proof checks only one of them", the token following the prompt (report, Section 6). Checking every token of a reply instead made no measurable difference to speed, which, counted in checked tokens only, is 39.1 tokens per second. The performance guide adds the conditions of that test: stored replies of 31 to 500 tokens, "chosen because scoring expected them to meet the limits", checked under a looser "clipped-gap" policy rather than exact match. The performance guide adds that one proving pass is 20.1 times slower than decoding the same number of tokens at 512 streams, and that since a pass checks one token "this is not the cost of proving a generated reply".
- Latency. In batches, a request waits about five minutes for its proof; proving requests one at a time gives a proof in 58 seconds at 17.6 tokens per second.
- Verifier. The client downloads 6.24 MB once per commitment (the post says "~6.5 MB") and then one proof per request; checking takes 17 seconds on 24 threads, 21 seconds on one, on a CPU with no GPU.
- Overhead against plain inference. Against vLLM running the model's FP8 release on eight H100s, per GPU, proving a batch of 24 takes about 72 times as long as vLLM's prefill of the same 24 requests (66 to 77 across runs) and about 94 times as long as vLLM at the highest load tried (report, Section 6; the guide gives 71.4, 65.2 to 76.4, and 93.0, 92.2 to 94.1). The guide notes that the vLLM runs were on other days, that their rates "are not the most that those machines can do", and that "a baseline that is too low flatters the prover".
Comparison with earlier systems. The post's "Prior work" section reports, from each system's own publication, rates from about 0.001 tokens per second (several 2023 to 2025 systems) to 2.9 tokens per second for DeepProve on GPT-2, 1.25 for SASH on Llama 3.1 8B, and 53 to 77 for Attestable's commercial prover on Gemma 4 31B, which has no open-source release. The only earlier proof of Llama 4 Maverick it knows of, VerInf, reports 14.3 hours for 1,000 tokens with a 93.6 GB proof. These figures come from different models, hardware and definitions of a proved token, and were not rerun; the post's conclusion is that overhead of "roughly 2 orders of magnitude" over native computation is achievable, "much less than previously expected".
Formal verification and what it covers
The protocol and its three properties (completeness, soundness and zero knowledge) are stated and proved in Lean, in the random oracle model (post, "Trustworthiness from formal verification"; report, Section 4). The repository states a soundness error of about q/2^124 + 2^-101 after q hash queries. The report says the formal statements "have been checked for correctness both by hand and by an AI agent" and that an expert should be able to audit them in a few hours.
The report is explicit about what is not covered (Section 7):
- The fast code is not proved. The C++ prover and verifier were "obtained by AI agents from their Lean representations", and their equivalence to the Lean specification is not proved. A mistake in the prover can affect completeness or zero knowledge, but not soundness, which depends only on the verifier. A slower verifier written in Lean is formally sound, given trust in the Lean kernel and compiler; the post says the C++ verifier agreed with it "on every proof in our tests".
- Zero knowledge for batches. Zero knowledge is proved when requests are proved one at a time, "not yet when they are proved together in a batch", which is how the measured system runs.
- Imperfect completeness. Range checks are approximated with random sums, so an honest prover is occasionally rejected, and a rejection "might leak information about the weights"; a fix is planned (Section 5.3).
- The protocol description. A separate, longer protocol document in the repository "was AI-generated, and we did not review it in detail"; the report itself "was written by its authors". The post describes that document as "Claude-written".
The post says that "Claude has produced improvements on zkSNARKs for inference" and "found novel ways to apply state-of-the-art tools". The report attributes the generated code and the protocol document to AI; neither document separates which design decisions were Claude's and which were the authors'.
Limitations
- Integer model, greedy decoding. A proof states that each checked token is the integer model's greedy choice. A reply from a floating-point implementation, or from sampled decoding, can depart from that and no longer match. The integer model is said to be within a small error rate of floating-point inference, "though this does not cover adversarially designed prompts" (post, "Limitations"; report, Section 7). The performance guide quantifies the gap: the integer model's top token differs from the 16-bit model's at 6.81% of positions (from a Python implementation, not the released programs), and of 96 stored replies each from ordinary vLLM serving at 16 bits and at FP8, none passed at exact match; 48 of 48 short replies passed when vLLM ran a plug-in that computes the integer model exactly.
- The repository is more cautious than the post. Its weight-hiding guide states that the Lean zero-knowledge theorems concern a Lean definition of the prover, "not the CUDA prover", that a written proof of hiding is "not public and not settled", and that "There has been no independent security audit".
- Detection after the fact. Post-hoc proving does not stop an incorrect response from being served; it detects tampering later, and an adversary could leak information through a tampered response before the failed proof is noticed. The operator must also trust its logs (report, Appendix).
- Architecture not hidden. The weights are hidden; the architecture is public, and the system assumes an MoE model.
- Short context. Requests are limited to 1,024 tokens, far below the context windows of frontier models.
- Side channels, such as the time taken to prove, are out of scope.
- Single GPU. Multi-GPU proving, which would lower latency, is not supported.
- One open model. All measurements are on Llama 4 Maverick, not on any Anthropic model, and the release does not show the system working on a production deployment.
Research questions
- What does it cost to prove generated replies? Measurements that check every generated token under realistic decoding, with the overhead against a well-tuned inference baseline, would show the cost for the tamper-detection and provenance uses the post proposes.
- Can the AI-generated code be shown equivalent to the Lean specification? A formal proof of equivalence for the verifier, or an independent audit of both programs, would close the gap the report states.
- Does zero knowledge hold for batches? A Lean proof covering batched requests, and a resolution of the approximate range checks, would cover the configuration actually measured.
- How well can benign numerical differences be separated from tampering? Testing the statistical methods the report cites against floating-point serving and adversarially chosen prompts would show how much room an attacker retains.
- Does the approach scale to dense models and long contexts? Results at context lengths of 100,000 tokens or more, and on dense architectures, would show whether the "2 orders of magnitude" overhead holds beyond this setting.
- What would a regulator need in practice? A worked design for one of the post's governance uses, with costs, coverage of requests and what proofs cannot show (for example training on the side), would show which proposals are feasible.
How it connects
- Trusted hardware. Confidential Inference via Trusted Virtual Machines (June 2025) describes Anthropic's hardware-based approach to protecting weights and user data; the provable-inference post contrasts software proofs with trusted execution environments but does not cite that post. The connection is this note's.
- Tampered inference as a threat. A Toy Evaluation of Inference Code Tampering studies whether a model could modify inference code to evade monitoring, one of the threats the post's tamper-detection use addresses. The connection is the note's.
- Other Frontier Red Team work with cryptography. Discovering cryptographic weaknesses with Claude (July 2026) and Claude reveals ECDSA curve origins (October 2026) use Claude to attack or explain cryptographic constructions; this post uses Claude to help build one. The connection is the note's.
References
- Rinberg, R., Allain, A., Chiesa, A., Christ, M., Dalal, R., Fenzi, G., Mayer, B., and Weissenberg, G. (2026, November 2). Progress on provable inference for large language models. Anthropic. https://www.anthropic.com/research/provable-inference record
- Rinberg, R., et al. (2026, November). FlashProve: an open-source library for provable inference. Technical report, 23 pages. https://www.anthropic.com/document/flashprove-technical-report record
- Anthropic. (2026). FlashProve, version 0.16.0, commit 9e2bdd8 (30 October 2026). https://github.com/anthropics/FlashProve. README, guide/performance.md and guide/weight-hiding.md read; the Lean proofs and the AI-generated protocol description were not read. record
- Karvonen, A., Reuter, D., Rinberg, R., Marks, L., Garriga-Alonso, A., and Warr, K. (2025). DiFR: inference verification despite nondeterminism. arXiv:2511.20621. Cited in the report; not read for this note. record
- Rinberg, R., Karvonen, A., Hoover, A., Reuter, D., and Warr, K. (2025). Verifying LLM inference to detect model weight exfiltration. arXiv:2511.02620. Cited in the report; not read for this note. record