FlashProve: Provable Inference for LLMs, Open Source
Anthropic released FlashProve on November 2, 2026, an open source prototype for provable inference. The system attaches a cryptographic proof to each model response. Anyone holding the proof, the prompt, and the response can check that the response really came from one specific committed model, without access to the model weights and without a GPU.
The measured target is Llama 4 Maverick, a 400B parameter mixture of experts model with about 17B active parameters per token, served with its public 4-bit quantized weights. On a single H100 GPU, proof generation runs at about 110 tokens per second. The cost is steep: proof generation takes roughly 70 to 95 times the GPU time of serving the same request with vLLM. Verification is the cheap side of the design, and that asymmetry is the point of the release.
Release Overview
FlashProve ships under the Apache 2.0 license with code, Lean proofs, and a technical report. The author list reaches beyond Anthropic and includes researchers from EPFL, MIT, StarkWare, and Succinct. Anthropic frames the release as the delivery of a public commitment: its Frontier Safety Roadmap set a goal of building a provable inference prototype by September 30, 2026, and the company says a separate project met that goal.
The problem it addresses is mundane and hard to audit today. A routing service can quietly swap in a cheaper model, and an attacker can alter a token stream in transit. A user who only sees the output has no way to tell. Teams that consume models through intermediaries have, until now, had to take the provider's word for which model actually ran.
How the Commitment and Proof Work
The provider first publishes a commitment to the model weights. A commitment is a short fingerprint that binds the provider to exactly one set of weights while revealing nothing about the weights themselves. Each response then carries a proof file. A verifier who holds the commitment, the prompt, and the response can check on CPU alone that the response is an output of the committed model.
The approach is built on zkSNARKs, zero knowledge succinct arguments of knowledge. The practical shape matters more than the cryptography brand. The expensive work sits with the provider, who runs the model anyway, while the checking work is small enough for an evaluator, a regulator, or a customer to run on ordinary hardware. That split is what makes third party checking realistic rather than theoretical.
Measured Performance
- Proof generation: about 110 tokens per second on a single H100 GPU.
- Proof size: about 19 MB per 1,024 token request, measured at 18.78 MB.
- Verification download: the commitment is about 6.5 MB.
- Verification time: 17 seconds on a 24 thread CPU, 21 seconds on a single thread.
- Offline commit step: about 39 minutes per model, and one commitment covers about 16 million requests.
- Online step: a batch of 24 requests processed in about 223 seconds.
Read together, these numbers rule out proving every response in a consumer chat product. At 70 to 95 times the inference cost, full coverage would multiply a serving bill by an amount no operator will pay for reassurance alone. The numbers fit a narrower pattern instead: sample a fraction of traffic, prove the responses attached to high value contracts, or let an evaluator confirm that the model it tested is the model being served. In those settings the proof cost is a small line item next to the cost of trusting the wrong model.
Limits Stated in the Release
- Integer arithmetic and greedy decoding only. The proof covers an integer version of the model with greedy decoding. Responses from a floating point implementation or from sampling based decoding can diverge from the computation the proof guarantees.
- Context capped at 1,024 tokens. Real conversations accumulate tens of thousands to millions of tokens of context, far beyond the current limit.
- No formal guarantee for the fast verifier. The C++ verifier used in practice has no formal assurance, and Anthropic explicitly does not guarantee that the Lean specification matches the executed code.
- Architecture is not hidden. The model architecture stays public, and side channel attacks that time proof generation are out of scope for this release.
These limits define the honest reading of the result. FlashProve shows that provable inference for a frontier scale model is feasible at all, with verification cheap enough for outsiders to run. It does not yet show a production path, because the proved computation is a simplified version of how models are actually served, at a context length real workloads passed long ago.
Practical Significance for API Buyers
The near term audience is not end users. It is the layer of evaluators, enterprise buyers, and routing intermediaries who currently sign off on model identity based on documentation and trust. A proof turns that sign off into a checkable artifact. An evaluation lab can confirm that the served model matches the tested model. A buyer can sample routed traffic and detect a silent model swap. Neither check requires the provider to expose weights, which removes the usual objection to opening the serving stack to inspection.
The open question is economic rather than cryptographic. Proof generation at 70 to 95 times inference cost will fall as the techniques improve, and the release gives the field a concrete baseline to improve on: 110 tokens per second, 18.78 MB proofs, 17 second CPU verification. Future systems will be judged against those three numbers.
Related Reading
For another Anthropic release covered here, see Anthropic RSI S1a, covering Anthropic work on recursive self improvement measurement. FlashProve sits at the opposite end of the trust problem: instead of asking what a model can do, it asks whether the model that answered is the model that was promised.
FAQ
What is FlashProve?
FlashProve is a provable inference research prototype that Anthropic open sourced on November 2, 2026 under the Apache 2.0 license. It attaches a cryptographic proof to each response so anyone can check that the response came from a committed model, without seeing the model weights.
How fast is proof generation and verification?
On a single H100 GPU, proof generation runs at about 110 tokens per second and takes roughly 70 to 95 times the GPU time of plain vLLM inference. Verification is much cheaper: checking a proof takes 17 seconds on a 24 thread CPU and 21 seconds on a single thread.
What are the current limits of FlashProve?
The proof covers an integer arithmetic version of the model with greedy decoding only, and the context limit is 1,024 tokens. The fast C++ verifier used day to day carries no formal guarantee, and Anthropic does not claim that the Lean specification matches the executed code.
Will Anthropic maintain FlashProve?
No. The GitHub repository describes FlashProve as a research artifact. Anthropic states that it will not maintain the code and will not accept contributions.