
Key points
- FlashProve generates proofs at roughly 110 tokens per second for a 400B-parameter model on a single H100 GPU.
- The system produces proof sizes of approximately 19 MB for every 1,024-token request using 4-bit quantized weights.
- Proof generation takes 70 to 95 times longer than running the model itself via the vLLM library.
Anthropic published a research post detailing progress on provable inference for large language models through a system called FlashProve. This work addresses the inability of users to verify that responses originate from the specific model claimed by a provider.This system lets users prove that an AI response came from the specific model they paid for.FlashProve leverages zkSNARKs to achieve provable inference speeds significantly exceeding prior open-source benchmarks.
The evidence
Anthropic researchers Roy Rinberg, Alex Allain, Alessandro Chiesa, Miranda Christ, Rahul Dalal, Giacomo Fenzi, Ben Mayer and Guy Weissenberg described how cryptographic proofs can solve verification issues in AI interactions. They noted that current users cannot distinguish between a claimed model and one substituted by a routing service or an attacker.
The team focused on zkSNARKs, a type of cryptographic proof offering strong hiding and efficiency properties. According to the post, FlashProve substantially outperforms prior open-source systems in speed.reported For a large mixture-of-experts model like Llama 4 Maverick with 400 billion parameters, the system achieves specific throughput metrics.reported
The decision
A single H100 GPU generates proofs at around 110 tokens per second for the 400B-parameter model. This performance uses 4-bit quantized weights and integer arithmetic during the prefill phase. Each proof covers a 1,024-token request and results in a file size of approximately 19 MB.
The authors state this speed is roughly 70 to 95 times the GPU time required to run the model itself using vLLM. Prior open-source systems are described as being orders of magnitude slower than this new approach. The system relies on novel applications of existing cryptography tools while adhering to established design principles.
The takeaway
FlashProve hides the model weights within the commitment and inference proofs, but it does not hide the model architecture. The researchers emphasised that concealing the architecture is not a goal of this system. The primary benefit is allowing providers to commit to a model and prove each response came from it.
This capability could enable applications ranging from consumer products to internal security measures. It may also contribute to toolkits for verifying compliance with AI pacing requirements. The system offers a way to cryptographically verify model identity rather than relying on output quality alone.
Building on this
Developers can build verification layers that confirm response origins using zkSNARKs. They can integrate FlashProve to hide model weights while exposing architecture details. Builders must account for significant computational overhead, as proof generation is much slower than inference.
Enterprise IT buyers can use these proofs to prevent model substitution attacks. They can verify that routing services have not swapped models for cost reasons. Developers should note that judging model identity by output quality remains unreliable without such proofs.
Why it matters
- Enterprise buyers can verify that responses come from specific models, preventing substitution by routing services or attackers.
- Developers gain a method to hide model weights while proving inference authenticity, though architecture remains visible.
- The system offers a potential toolkit for verifying compliance with AI pacing requirements through cryptographic proofs.
- Proof generation is significantly slower than inference, requiring careful resource planning for real-time applications.
Topics: AI security, cryptographic proofs, Anthropic, model verification, zkSNARKs
Updated
Then / now / next
Users could not verify if AI responses came from the claimed model or a substituted one.
Anthropic’s FlashProve enables cryptographic verification of model identity with improved speed.
Watch for applications of these proofs in consumer products and internal security systems.
Story timeline
- Then Users could not verify if AI responses came from the claimed model or a substituted one.
- 04 Nov 2026 Progress on provable inference for large language models
- Now Anthropic’s FlashProve enables cryptographic verification of model identity with improved speed.
- Next Watch for applications of these proofs in consumer products and internal security systems.
The strongest doubt
Counterpoint from the sources
The proof generation process is 70 to 95 times slower than running the model itself, which may limit real-time applicability.
For readers
Developers
- Can build systems that verify model identity using zkSNARKs while hiding weights.
- Must manage significant computational overhead compared to standard inference.
Business
- Can prevent model substitution by routing services or attackers in production.
- May use proofs to verify compliance with AI pacing requirements.
Researchers
- Can study novel applications of cryptography tools in AI security.
- Can explore tradeoffs between proof size, speed and weight hiding.
Ask the article
Local keyword search of this article; no generated answers.Did this article give you the evidence you needed?
Your choice stays on this device. No public tally.Questions readers ask
What is the performance of FlashProve on large models?
It generates proofs at around 110 tokens per second for a 400B-parameter model on a single H100 GPU.
Does the system hide the model architecture?
No, the system hides the model weights but does not hide the architecture, which is not a goal.
How does the speed compare to running the model?
Proof generation takes 70 to 95 times the GPU time of running the model via vLLM.
Connected stories
Reading receipt
- FlashProve generates proofs at roughly 110 tokens per second for a 400B-parameter model on a single H100 GPU.
- The system produces proof sizes of approximately 19 MB for every 1,024-token request using 4-bit quantized weights.
- Proof generation takes 70 to 95 times longer than running the model itself via the vLLM library.
Still open: How will proof sizes scale for larger models or longer requests?
Still open: What are the exact computational costs for integrating this into existing inference pipelines?