Anthropic’s FlashProve prototype checks that a reply came from one committed model
A research post dated Monday releases code, under Apache 2.0, that proves Llama 4 Maverick’s 4-bit weights produced a token. On one H100 the proofs run at about 110 tokens a second, and a 1,024-token proof is about 19 megabytes. TechCrunch reported Tuesday that Anthropic has no plan to deploy it.
Feature6 minIn-depth
Priya Shah6 min read
- Anthropic
- Security
- Cryptography
- Models

Photo: AnthropicSource page
Anthropic has published a research prototype, FlashProve, that lets a model provider attach a cryptographic proof to a reply so someone else can check that one committed set of weights produced it. The post is dated 2 November and credited to the Frontier Red Team, with authors at Anthropic, EPFL, MIT, and StarkWare. Russell Brandom at TechCrunch, in a story timestamped 2:41 p.m. Pacific on Tuesday, 23:41 in Amsterdam, reported the release and wrote that there are no plans to deploy the system at Anthropic or at any other lab. The post itself is narrower than a product announcement. It calls the release intermediate, and it measures the prototype on a Meta model, not on Claude.
This research post is meant to share intermediate progress, and not a completed research agenda. We are sharing this explicitly with the goal that others look at what we have done, take it, and improve it.
— Anthropic, “Progress on provable inference for large language models,” 2 November 2026
The number the post leads with is a speed. For Llama 4 Maverick, a 400-billion-parameter mixture-of-experts model, using a public 4-bit conversion of the weights, a single H100 generates proofs at about 110 tokens a second. A proof covering a 1,024-token request is about 19 megabytes. The post says that is roughly 70 to 95 times the GPU time of running the model itself on vLLM, a common open-source inference library. About 17 billion of the 400 billion parameters are used per token. The weights are not in the release. Readers download them from Hugging Face under Meta’s Llama 4 license. The code, the Lean proofs, and the documentation are under the Apache 2.0 license.
What a passing proof actually certifies
FlashProve has two phases. Offline, the provider publishes a short commitment to the weights, a fingerprint of one exact choice, while the weights stay hidden. Online, for a prompt and a reply, the provider produces a proof file of the statement the post puts in one line: “The committed model produces these output tokens when evaluated.” Anyone with the commitment, the prompt, and the reply can check that file without the weights. The post says an honest proof is accepted, and that forging a proof of a false statement is tantamount to breaking widely believed cryptographic assumptions. It also says the proof reveals nothing about the weights, the intermediate values, or which experts ran. The architecture is not hidden. Hiding it is left as future work.
The evaluation section is more particular than the round numbers. The prover runs on one H100 and 24 CPU cores. The offline phase takes about 39 minutes and, for technical reasons the post points at the technical report, the resulting commitment is good for about 16 million requests, after which the provider has to commit again. A batch of 24 requests takes the prover about 223 seconds, which is the 110 tokens a second, and each proof in that run is 18.78 megabytes. The client downloads a commitment of about 6.5 megabytes, then one proof per request. Checking a proof takes 17 seconds on 24 threads and 21 seconds on a single thread, including the offline checks. The attested run is a quantized model of about 232 gigabytes. The post says the system is built to fit on one 80-gigabyte GPU, with about 290 gigabytes of host memory beside it, because the weights are streamed in rather than held on the card.
The vLLM comparison is per GPU, and it is not the same weight format. Anthropic ran vLLM on the FP8 release of the same model, on eight H100s. Per GPU, proving a batch of 24 requests took about 72 times as long as vLLM took to process those requests together, with a range of 66 to 77 across runs, and about 94 times as long when vLLM was at the highest load they tried. The proofs are post-hoc. The prover reads finished text after the fact, in one parallel pass, rather than proving alongside the generation. The post says in-line proving would have to be faster and might give up security to get there. Post-hoc proving, it says, adds the cost of recomputing, delays the guarantee, and has to live with the fact that a floating-point run is not a single determined string of tokens.
A gap between the proof and a chat reply
The limitations section is where the prototype stops being a general answer to “which model said this.” The proof is about an integer version of the published weights, under greedy decoding. Each checked token is that model’s greedy choice. A reply from a floating-point implementation, or from sampled decoding, can depart from the computation that was proved. The post says the integer version is generally expected, and has been empirically tested, to stay within a small error of ordinary floating-point inference, and that this does not cover prompts designed to force a difference. The context being proved is at most 1,024 tokens. The post says that is short of the contexts chat products accumulate, which it puts in the hundreds of thousands to millions of tokens. Timing and other side channels are out of scope: the guarantee is about what the proof file reveals, not about what a clock might reveal.
There is a second gap, between the mathematics and the fast program. Anthropic specifies the protocol in Lean and proves completeness, soundness, and zero knowledge in the random-oracle model. It also ships an executable Lean verifier, which is slow, and a C++ verifier, which is the one meant for day-to-day use. The post says the C++ verifier carries no formal guarantee. It agreed with the Lean verifier on every proof in their tests. The paper and the fast code are derived from the Lean protocol, and Anthropic does not guarantee that all three match. A footnote says the model’s architecture is not hidden, and that hiding it is future work.
Not the September prototype Anthropic already counted
The post ties the work to a goal Anthropic had already said it met, by a different method. In the Frontier Safety Roadmap the company set out to “develop a prototype by September 30, 2026 of provable inference,” a way of signing outputs so they are attributable to a specific set of weights. A footnote says that, as stated in the Responsible Scaling Policy updates, Anthropic met that goal with a separate project, which signs inference traffic and recomputes inference on a trusted server. An update on 19 October renamed the goal “inference verification,” because “provable inference” suggested a narrower approach than the company thought it needed. The cryptographic proofs in this post are described as one more way to get high assurance in the token stream, not as the prototype that closed the September item.
The post also places the speed against earlier proofs of the same model. The only earlier proof of Llama 4 Maverick it says it knows of, VerInf, reported 14.3 hours for 1,000 tokens on a DGX Spark, about 0.02 tokens a second, with a 93.6-gigabyte proof that took almost a day to verify. A commercial system, Attestable, is cited at 53 to 77 tokens a second for Gemma 4 31B on one H100. The post says Attestable had not released a corresponding open-source library at the time of writing. Brandom’s account of the use is the one a customer would recognize: a lab could not quietly swap in a cheaper model, or a more expensive one, and still produce a proof that checks against the published fingerprint. The fingerprint does not reveal the weights. The post’s own list of cases is wider than a billing dispute. It includes an evaluator who needs to know the model being served is the model being tested, a regulator asking for certificates that hardware was used for inference of a named model, and a developer who wants to show that a particular model spent a stated number of tokens looking for bugs and did not find them. None of that is running on Claude’s API. The release is the code, the proofs, and the measurements on Maverick.


