FlashProve: Anthropic prototype can prove which AI model is answering

What's new

Anthropic has released FlashProve as an open research prototype. According to Crypto Briefing, the code appeared on GitHub on November 2, 2026, under the Apache 2.0 license, so anyone can use it and build on it. Lean proofs and documentation are included.

The idea is that an AI provider can prove which model answered a request without revealing the model's weights. The weights are the numbers that make up the model's "brain" and are typically a company's biggest secret. It is not a product you can buy or subscribe to, but research code.

What's clever

The method has three steps. First, the provider publishes a commitment ID, a kind of digital fingerprint tied to one specific set of secret weights. Next, for each response, the provider's GPU produces a proof that the response comes from exactly that model. Finally, anyone can check the proof without seeing the weights.

The check is light: According to Crypto Briefing, verification takes 17-21 seconds on a standard CPU, and GitHub states that it requires only Linux and under 2 GB of RAM. The system is built on hash-based zkSNARKs, a type of zero-knowledge proof that lets you convince others that something is true without revealing the secret data. According to Crypto Briefing, it targets mixture-of-experts models, where only part of the model is active at a time.

According to Anthropic's repository, soundness is proven in Lean 4. According to it, a provider trying to cheat is caught, except with a probability of roughly q/2^124 + 2^-101 after q hash queries. That holds under the assumptions the repository lays out. Roy Rinberg and Alex Allain of Anthropic are named as lead researchers, and Alessandro Chiesa (EPFL/StarkWare) contributed as a cryptography expert.

Cheaper or better?

Price is not relevant yet: There is no pricing, and commercial availability or conditions in Denmark and the EU are not mentioned. Competitors such as other zkML projects are not compared with FlashProve in the sources. The claim that FlashProve is more efficient than earlier open methods comes from Anthropic's own post and has not been independently verified.

The expensive part is producing the proofs. Anthropic tested on Meta's Llama 4 Maverick (400.7 billion parameters, 4-bit quantized) on a single NVIDIA H100 with 1,024 tokens of context. According to explainx.ai, the figures are Anthropic's own measurements, which explainx.ai has not rerun. The speed is roughly 110 tokens per second at batches of 24 requests, but there is disagreement about what the figure covers: GitHub calls it prefill speed, while Crypto Briefing and explainx.ai describe it as proof generation. According to Crypto Briefing, a proof takes up roughly 19 MB per request at 1,024 tokens, and a batch of 24 takes roughly 223 seconds. According to Crypto Briefing, creating the commitment takes roughly 39 minutes and yields roughly 6.5 MB. In total, according to Crypto Briefing, proof generation requires roughly 70-95 times the GPU time that ordinary vLLM inference uses. Crypto Briefing judges that the overhead makes the prototype impractical for production, while explainx.ai says that ongoing proof generation is impractical for user-facing APIs.

There are also narrow limits: only greedy decoding (the model always picks the most likely next word) and context of up to 1,024 tokens. The full Llama 4 Maverick route requires an H100 80 GB, CUDA 13.2, roughly 330 GB of RAM and 245 GB of disk. The repository is not maintained and does not accept contributions.

What it's good for

FlashProve is for researchers and developers who want to explore how to trust what an AI service is actually running. Suggested uses include oversight of the allocation of advanced hardware, detection of tampered inference servers and documentation of models' provenance.

For ordinary users and businesses, it changes nothing right now. explainx.ai judges that FlashProve is best seen as one possible path to high assurance in the token stream and not as a finished production solution. The overhead makes ongoing proof generation impractical for user-facing APIs.