FlashProve: Provable Inference for LLMs, Open Source

Provable inference · ax-trend issue #3748 · Released November 2, 2026

FlashProve provable inference title card

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.

Proof generation, single H100110 tokens/sec
Cost vs plain vLLM inference70 to 95x GPU time
Proof size per 1,024 token request18.78 MB
Verification, 24 thread CPU17 seconds

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

How FlashProve verification works in three steps
Commit once to the weights, attach a proof to every response, and let anyone verify on CPU without the weights.

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

Cost of proof generation compared with plain inference
Proof generation takes 70 to 95 times the GPU time of plain inference in Anthropic measurement.

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

FlashProve is a research prototype. The limits below are stated by Anthropic in the release itself, and the GitHub repository says the code will not be maintained and contributions will not be accepted.

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.

Sources

AnthropicFormal VerificationAI InfraAX Trend