FlashProve: Anthropic’s cryptographic proof for checking which AI model produced a response
Image generated by the Inferama Editorial Team
01

What FlashProve is designed to do

Anthropic published FlashProve on November 2, 2026, as an open-source research prototype under the Apache 2.0 license. It is designed to check cryptographically whether an output token matches the output of a model committed to in advance, without requiring the user to access the model’s weights.

The project targets the risk of model substitution by an intermediary. A user may not be able to tell whether a service returned a token produced by the model the user selected or paid for, rather than by a different model. FlashProve aims to give independent evaluators, business customers, and regulators a way to check the model associated with an output. It does not assess whether the output is accurate or safe.

02

How the cryptographic check works

FlashProve uses a zero-knowledge succinct non-interactive argument of knowledge, or zkSNARK. In broad terms, the provider sends a cryptographic proof along with an output. A user can check the proof locally without receiving the model’s weights or repeating the model’s full computation.

The process starts with a cryptographic commitment to the model weights: a short identifier that binds the proof to a particular set of weights without disclosing them. For a request, the provider then creates a proof linking that commitment to the input and an output token. The client checks the proof using the commitment, input, and token. The protocol is intended to keep the weights and intermediate calculations private, but it does not hide the model’s architecture. The commitment must also come from a source the client trusts; a server being checked should not be allowed to supply the only identifier used to check its own response.

The verification flow

  1. 01The provider publishes a cryptographic commitment to the model’s weights, once for that model.
  2. 02The user sends a request to the model through the provider.
  3. 03The provider generates an output and a cryptographic proof associated with an output token.
  4. 04The user receives the output and the proof.
  5. 05The user checks the proof locally against the trusted commitment, input, and token, without accessing the weights.
03

What Anthropic’s performance test measured

Anthropic tested a 4-bit quantized version of Meta’s Llama 4 Maverick. The test processed batches of 24 requests, each with a 1,024-token context, using an Nvidia H100 GPU and a server with 24 CPU cores. Anthropic reported that each proof covered one output token and was about 19 MB in size.

Checking a proof took 17 seconds with 24 CPU threads or 21 seconds with one thread, according to Anthropic. The reported rate of about 110 tokens per second refers to processing the contexts in that test; it does not mean that 110 output tokens per second were individually verified. Generating proofs also required substantially more computation than processing the same requests with vLLM. Anthropic reported an overhead of roughly 70 to 95 times in GPU time under its comparison conditions. These figures describe that experiment, not a general performance guarantee.

Performance figures reported by Anthropic

Measurements for a 4-bit version of Llama 4 Maverick under the test conditions described by Anthropic.

MeasureReported result
Proof sizeAbout 19 MB for a request with a 1,024-token context
Proof verification on CPU17 seconds with 24 threads; 21 seconds with one thread
Processing rateAbout 110 tokens per second during context processing (prefill) on one H100
Overhead compared with vLLMAbout 70 to 95 times the GPU time in Anthropic’s comparison
Initial model commitmentAbout 39 minutes; reusable for roughly 16 million requests
04

What FlashProve does—and does not—verify

The demonstration checks a specific integer, 4-bit quantized version of Llama 4 Maverick. It assumes greedy decoding, in which the model selects the highest-scoring token at each step. A model run with floating-point calculations or sampling can produce a different token sequence, so its output may not match the one covered by the proof.

The prototype supports contexts of up to 1,024 tokens and creates proofs after the text has been generated. In the reported test, a proof covered one output token, not every token in a response. Acceptance therefore establishes a limited claim: that the committed model produced the token under the specified calculation and decoding conditions. It does not establish that the response is true, safe, useful, or appropriate.

Declared technical and scope limits

These restrictions apply to the FlashProve prototype and its reported demonstration.

LimitWhat it means
Greedy decodingOutputs generated with floating-point calculations or sampling may not match the proof’s token.
A specific model structureThe demonstration uses a mixture-of-experts model; the proof does not conceal the model’s architecture.
Contexts up to 1,024 tokensThe tested context length is limited compared with the much longer contexts used by some leading models.
Side channels are out of scopeInformation such as proof-generation time could potentially reveal details and is not covered by the stated scope.
Executable code lacks a formal guaranteeFormal results do not automatically establish that the optimized code, report, and formal specification match in every respect.
05

Formal verification and implications for trust

Anthropic used Lean, a tool for checking mathematical proofs, to formalize security properties of the protocol. The company cautions that this formal work does not automatically guarantee that the optimized executable code, the technical report, and the formal version correspond perfectly. Potential side channels, such as how long proof generation takes, are outside the declared scope.

Anthropic has also used Claude to help build verification tools in earlier work, where the formal proofs concerned properties of parts of software libraries. FlashProve instead concerns calculations associated with a model’s output. A successful proof could help an evaluator check whether a model under test is the one being served, or help a customer check whether a provider used the committed model. Those uses depend on a trusted commitment and a correctly constructed request; the proof alone does not confirm that the input file represents the user’s actual prompt and response.

The distinction matters for trust and oversight. Cryptographic verification can provide a check on which committed model produced a specified token, but it cannot by itself establish the quality of the model’s answer or the provider’s broader conduct. FlashProve remains a research prototype, and Anthropic’s test covers a particular model configuration rather than model serving in general.

06

Keep exploring

Sources consulted

03

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