FlashProve offers a way to check that selected AI output tokens follow a specified computation using committed model weights, without giving the checker those weights. Connecting that cryptographic commitment to a name such as a particular commercial model requires a trusted source for the model’s identity and settings.

That is the useful distinction in Anthropic’s research release of 2 November. A provider could supply evidence about how an answer was computed. The proof would leave questions about the answer’s accuracy, the model’s suitability and the authenticity of its label to other checks.

The performance figures need a similarly precise reading. Anthropic reports roughly 110 tokens per second for producing proofs on one H100 GPU. Those are input positions processed while proving a computation over supplied text. They are not 110 newly generated answer tokens per second.

What the proof says about a checked token

FlashProve separates two jobs. The prover, typically the provider holding the weights, produces cryptographic evidence. The verifier checks that evidence using public files and the claimed token computation, without rerunning the large model.

A weight commitment fixes the weights used in the protocol without publishing them. A zkSNARK is a compact cryptographic argument that makes this kind of checking possible while keeping the weights private under the protocol’s assumptions.

According to the repository’s statement of what is proved, the intended exact-match claim is that each checked token is the committed integer model’s highest-scoring choice at that position, given the preceding token IDs.

Both “checked” and “integer” matter. The current full-size request uses a 1,024-position window containing the prompt, reply and any filler, with a specified range to check. A proof covering one next token does not establish the computation of an entire response. The headline benchmark uses 1,024-token prompts and proves the next token.

The model also uses integer arithmetic and greedy decoding: it selects the highest-scoring next token. Ordinary inference using floating-point arithmetic or sampling can produce different results. FlashProve therefore needs a precisely defined computation to check; an accepted proof is not a blanket certification of every way a model might be served.

There is also a tolerance-based acceptance policy, described in the guides as “clipped-gap.” An acceptance under that policy establishes the selected tolerance condition. It does not establish that every checked token was the exact greedy choice. Anyone consuming a proof must know which policy was used.

A model fingerprint needs a trusted introduction

Imagine a purchaser wants assurance that a supplier used an agreed model version for a task. The supplier sends an answer, a proof and a commitment ID.

If the supplier also supplies the only evidence that this ID belongs to the agreed model, the purchaser still depends on the supplier’s label. Cryptography can bind computation to committed weights; it cannot supply the missing trusted association between those weights and a commercial name.

The FlashProve README explicitly tells verifiers to obtain the commitment ID from a trusted party, never from the server being checked or from the proof files. The verification guide also requires trusted configuration files through a channel outside that server’s control, established before sending the prompt.

For a purchaser or evaluator, this implies an enrollment process: someone they trust must vouch for the exact model version, commitment and settings. The sources do not establish a deployed registry or standard independent authority that performs this job.

Renewal needs attention too. Commitments have usage limits, and an ID can change for operational reasons, including moving machines or changing settings. In general, a proof does not establish that two different IDs contain the same weights. Matching example outputs cannot settle that question. A system relying on named-model identity would need an authenticated process for accepting replacement commitments.

The client must match the proof to the actual exchange

The verifier does not see what the client originally sent. The client must construct or compare the request and token files against the actual sent and received token IDs, then check the covered range and acceptance policy.

That makes tokenization and formatting part of the trust chain. The tokenizer, chat template and end-token IDs need authentication too. A proof for a valid prefix can pass even if the response was truncated; claiming a complete reply requires an explicit end or length check.

These requirements follow from the acceptance guide. They explain why a green verification result needs context: which request, which tokens, which settings and which acceptance rule?

What the reported speed actually measures

Anthropic’s main test used Llama 4 Maverick, a 400-billion-parameter mixture-of-experts model with roughly 17 billion active parameters per token, using a third-party four-bit conversion. Proof production ran on one H100 with 80 GB of GPU memory, alongside substantial host resources.

The performance guide reports about 111 input tokens per second at a batch size of 24, with three runs. The blog rounds this to 110 tokens per second and approximately 223 seconds for the batch.

That counts 24 prompts of 1,024 tokens each. It recomputes supplied text to produce proofs; no response tokens are generated in that measurement.

The batch figure also explains a tempting misreading of cost. Dividing the processing time among 24 requests gives about 9.2 seconds per request as an amortized share. Each request still waits for the whole batch, roughly 221 to 226 seconds in the reported steady runs, plus queueing and serving-script verification. A single-request batch took about 59 seconds.

Anthropic compares the prover with stock vLLM running the same model in FP8 on eight H100s. Its reported 70–95 times GPU-time overhead is normalized by GPU count. The prover uses four-bit integer arithmetic, and the measurements come from separate runs. This comparison gives a sense of GPU work under those conditions; it does not measure a total service-cost multiplier or compare identical numerical precision.

Proving, verification and preparation have different costs

The following figures come from Anthropic’s evaluation and the repository’s performance guide. They are company-reported measurements, with no independent replication established here.

Cost category Reported result How to read it
GPU proof production About 223 seconds for 24 requests on one H100 Batch proof production over 1,024-token prompts; excludes startup and the provider’s own serving checks
Fast CPU verification About 17 seconds with 24 threads, or 21 seconds with one thread, including offline-phase checks No GPU required; these are reported machine results, not a phone or laptop benchmark
Commitment preparation About 39 minutes per commitment in the headline configuration An offline cost that must be spread over use; the provider retains about 2.15 GB per commitment
Proof transfer and storage Average proof size of 18.78 MB per request Applies to the measured request workload, not an arbitrary output token or reply length
Client commitment download Blog estimate of about 6.5 MB overall The guide’s 6.24 MB subtotal covers the key and leaf data and excludes three required configuration files

“One H100” also leaves out a sizeable host machine. The guide reports approximately 270 GB of host container memory during the batch-24 public-weight run, excluding cache.

The published measurements do not establish dollar or energy costs, network transfer time, archival costs or production client latency distributions. Startup, commitment preparation and provider-side checking are separate work. Adding numbers from different experiments would not produce a measured end-to-end service latency.

The practical shape is expensive proof production followed by lighter CPU checking. Whether that tradeoff suits a particular audit or procurement workflow depends on its timing, infrastructure and trust requirements.

Formal proof does not cover all the released code

FlashProve includes formal work in Lean, a system for defining mathematical statements and checking proofs. The guarantee guide describes a soundness theorem for the Lean verifier under specified configuration and cryptographic assumptions. In broad terms, soundness limits the chance that a dishonest prover can get a false computation claim accepted.

That theorem does not establish that the fast C++ verifier, CUDA prover and committer implement the proved protocol. Their correspondence rests on tests. The formal definitions themselves also need human review to determine whether they express the intended behavior.

This gap matters when reading the fast verification timings. The performance guide separately reports roughly 24 minutes for a Lean verifier experiment using a stored synthetic proof checking 1,001 tokens. It marks those programs as unreleased and describes different conditions, so this is not a controlled speed comparison with the fast verifier.

The prototype also exposes the model architecture, excludes timing side channels and limits context to 1,024 positions. Operational weight secrecy depends on correct handling of masking and secret state. Proof acceptance alone does not test whether the provider has fulfilled those duties.

What an evaluator can investigate today

Provable inference has an existing research history. For example, the independently authored zkLLM paper from April 2024 describes zero-knowledge proofs for large language models. Its models and workloads differ, so its published figures do not establish a direct FlashProve speed ranking.

As checked on 5 November, FlashProve’s repository identifies version 0.16.0 as a research artifact that is not maintained or accepting contributions. The release provides a prototype to examine, rather than an established Claude service capability. Anthropic also discusses a separate inference-signing and trusted-server recomputation prototype; that should not be read as a FlashProve deployment.

For an evaluator considering the approach, the useful questions are concrete: who authenticates the model commitment and configuration, which received tokens are covered, what acceptance policy applies, and how much delay and infrastructure can the workflow tolerate? A pilot would also need to measure the full path from the original request through proof receipt and client checks, including commitment renewal.