The trust problem in AI services
When a user interacts with an artificial intelligence model, there is currently no direct way to confirm that the response comes from the specific model the provider announces. This trust gap is exacerbated in environments where routing services might substitute an expensive model with a cheaper one to reduce costs, or where an attacker could manipulate the token stream without the user detecting it.
The quality of the response alone does not guarantee its origin. A model can generate coherent and high-quality outputs, but that does not prevent a routing system from having used a different model than the one promised. FlashProve seeks to close this gap by offering a mathematical verification that links the response to the committed model, allowing users and auditors to check the legitimacy of the output without needing access to the provider's computational resources.
Technical mechanism: Zero-knowledge proofs
FlashProve is based on a type of cryptographic proof known as a zkSNARK (zero-knowledge succinct argument of knowledge). This system allows a provider to demonstrate that a calculation was executed correctly without revealing the private data involved in the process. In this case, the proof links a previously committed set of weights with the tokens generated in response to a specific prompt.
The process is divided into two stages. First, the provider makes an offline cryptographic commitment to a specific set of weights; this commitment occupies around 6.5 MB and its generation takes about 39 minutes. Then, for each inference, the system builds a succinct proof that confirms the committed model produced the declared output. The privacy of internal components, such as weights and activations, remains intact during verification.
Verification flow in FlashProve
- 01The provider generates a cryptographic commitment of the model weights (offline phase).
- 02The user sends a prompt and receives the response along with a cryptographic proof.
- 03The user verifies the proof on their local CPU without needing to access the model weights.
- 04The verification confirms that the committed model generated the declared tokens.
Performance and computational costs
Anthropic evaluated the prototype using Llama 4 Maverick, a mixture-of-experts model with 400.7 billion parameters quantized to 4 bits. On a single NVIDIA H100 GPU, the system reached approximately 110 tokens per second in the prefill stage. Each request of 1,024 tokens produced a proof of around 19 MB, verifiable on a standard CPU in between 17 and 21 seconds.
However, the cost of generating these proofs remains high. Anthropic estimated that producing a proof requires between 70 and 95 times more GPU time than a standard inference performed with the vLLM library. This computational overhead keeps the project in an intermediate research phase, as it is not economically viable for verifying every interaction in massive services.
FlashProve performance metrics
| Metric | Value | Context |
|---|---|---|
| Evaluated model | Llama 4 Maverick (400B parameters, 4-bit) | Mixture of Experts (MoE) |
| Proof generation speed | ~110 tokens/second | On a single H100 GPU |
| Proof size | ~19 MB | Per 1,024-token request |
| Verification time | 17-21 seconds | On CPU (24 threads or 1 thread) |
| Computational overhead | 70-95x | Compared to standard inference in vLLM |
Formal guarantees and verification with Lean
To address the inherent fragility of cryptographic code, the Anthropic team used Lean, a formal proof assistant, to specify and verify the security properties of the system. The verified properties include completeness (an honest proof is accepted), soundness (a false proof cannot be accepted) and zero-knowledge (the proof reveals no information about the weights).
This formal verification does not replace performance tests nor solve the computational cost, but it offers a rigorous mathematical basis for the security guarantees. The team states that the formal properties were machine-verified, which reduces the dependence on informal code inspections. However, the correspondence between the executable code and the formalized protocol still requires manual auditing.
Potential applications and current limits
FlashProve has applications in tamper detection, text provenance, and regulatory compliance. For example, a regulator could require proofs to verify that a provider is serving only models approved as safe. It could also be used to demonstrate that a specific model performed a vulnerability analysis on a source code.
However, the prototype has clear limits. The evaluation was performed with a specific model (Llama 4 Maverick) and a specific hardware configuration (a single H100 GPU). It cannot be concluded that the performance is comparable on other models or configurations. Furthermore, the system does not detect all possible interventions in the service chain, but focuses on proving that the committed model generated the declared tokens. Reducing the generation cost and optimizing the size of the proofs will be necessary steps before widespread use.
Keep exploring
Corrections and transparency
If you spot incorrect or outdated information, send us a correction with the page and source we should review.
Submit a correction