JupiteX Get the app
Science & Technology17 Nov 2026 · about 7 min

Which model actually answered you? Paradox's FlashProve makes provable LLM inference practical

The brief

FlashProve is an open-source prototype for provable inference, developed by Paradox’s Frontier Red Team with researchers from EPFL, StarkWare, MIT and others. It addresses a gap in ordinary API responses: a model name is only a claim, not evidence. A proof can give clients and auditors a way to check which model produced a response. The provider first commits to one exact set of hidden weights. For a prompt and returned tokens, FlashProve then creates a cryptographic proof that the committed model produced those tokens when evaluated. Anyone with the commitment, prompt and reply can verify the claim, without learning the weights or running the model themselves. For Helix, FlashProve generates proofs at about 110 tokens per second on one H100. A proof for a 1,024-token request is about 19 MB, and checking it takes about 17 seconds on a 24-thread CPU. The system proves after inference, so guarantees can be delayed, and its compute cost is roughly 70–95 times serving with vLLM.

01

What is FlashProve, and what does its proof establish about an LLM response?

FlashProve is an open-source prototype for provable inference, developed by Paradox’s Frontier Red Team with researchers from EPFL, StarkWare, MIT and others. It addresses a gap in ordinary API responses: a model name is only a claim, not evidence. A proof can give clients and auditors a way to check which model produced a response.

The provider first commits to one exact set of hidden weights. For a prompt and returned tokens, FlashProve then creates a cryptographic proof that the committed model produced those tokens when evaluated. Anyone with the commitment, prompt and reply can verify the claim, without learning the weights or running the model themselves.

For Helix, FlashProve generates proofs at about 110 tokens per second on one H100. A proof for a 1,024-token request is about 19 MB, and checking it takes about 17 seconds on a 24-thread CPU. The system proves after inference, so guarantees can be delayed, and its compute cost is roughly 70–95 times serving with vLLM.

02

How does FlashProve link a provider’s committed model weights to a prompt and the exact tokens returned?

FlashProve links a response to a model in two stages. First, the provider commits to its weights: it publishes a short fingerprint that pins down one exact set while keeping the weights hidden. That commitment gives the client a reference point, rather than asking the client to trust a model name in an API response.

For a particular request, the prover uses the prompt and output tokens to produce a proof of the statement that the committed model produces those tokens when evaluated. Verification checks that statement against the commitment, the prompt and the reply. The proof therefore ties the response to the selected weights and request, not merely to a provider’s label.

The commitment is prepared offline and can be reused for about 16 million requests before the provider must commit again. On one H100, making it takes about 39 minutes, and clients download about 6.5 MB of commitment data. Proofs are made online, after inference, so checking can happen later and may cover only a subset of tokens.

03

How fast are FlashProve’s proofs, how large are they, and how long does verification take?

The headline performance figures are for Helix, a 400-billion-parameter mixture-of-experts model with 4-bit weights. FlashProve generates proofs at about 110 tokens per second on one H100. That measures proof generation, not ordinary model serving: proving adds substantial work beyond producing the response.

For a request with 1,024 output tokens, the proof is about 19 MB. Checking it takes about 17 seconds on a 24-thread CPU. The verifier does not need a GPU or the model’s hidden weights, and it checks the proof rather than re-running the full model. This makes verification much less demanding than recomputation, though the proof itself is not tiny.

The reported prover cost is roughly 70–95 times the GPU time needed to serve the same requests with vLLM. FlashProve works after inference and can prove only a subset of tokens, so a guarantee may arrive later rather than during generation. Its figures are a major improvement over earlier zkML results cited in the article, but proving still has significant compute and storage costs.

04

How could proof of a response help detect model substitution by a router or inference server?

A router or inference server can claim to use one model while secretly substituting a cheaper or otherwise different one. FlashProve is designed to make that kind of substitution checkable. Instead of trusting the model name in an API response, a client can check a proof against the provider’s commitment to its exact weights.

The proof covers a specific prompt and the exact output tokens. If a router returns tokens from a substituted model, those tokens should not satisfy the proof statement for the committed model and prompt. A verifier holding the commitment, prompt and reply can check the proof without access to the hidden weights or a GPU. The article also describes tampering by an attacker on an inference server as a use case.

This is evidence about which committed model produced the proved tokens; it does not make the response itself trustworthy in every sense. FlashProve proves after inference, potentially for only a subset of tokens, so detection may be delayed or limited to what was proved. Its reported cost is also roughly 70–95 times the GPU time of serving with vLLM.

05

Why does a mixture-of-experts model let FlashProve focus its work on only some of the model’s weights for each token?

Helix is a mixture-of-experts, or MoE, model. For each token, only some experts are used, rather than all the model’s parameters. The article says about 17 billion of Maverick’s 400 billion parameters are used per token. This gives FlashProve a way to avoid proving work for every weight in the full model on every token.

The key engineering choice is to prove only the experts that ran. As a result, prover work per token scales with the roughly 17 billion active parameters, rather than the entire 400-billion-parameter model. The proof still hides which experts were selected, so the verifier can check the computation without learning that detail.

This approach contributes to FlashProve’s reported speed of about 110 tokens per second on one H100 for Maverick. It does not eliminate the overall overhead: the article puts the cost at roughly 70–95 times the GPU time of serving the same requests with vLLM. The prototype also proves post-hoc, after inference, rather than adding a proof inline as each token is generated.

06

What does a valid FlashProve proof guarantee, and what does it not guarantee about the response?

FlashProve’s central guarantee is about provenance and computation. Given a commitment, prompt and reply, a valid proof shows that the exact committed weights produced the proved output tokens when evaluated. This can help establish that a model provider served the model it committed to, rather than merely claiming a model name in an API response.

The proof is cryptographic evidence about how the response was produced. It does not assess whether the tokens describe the world accurately, answer the question well, or meet a safety standard. Nor does it independently show that the provider’s chosen model was the model a user wanted; users still need to know which commitment they are checking.

The article presents applications including third-party routing, model evaluations, tamper detection, text provenance and regulatory approval of models. FlashProve proves after inference and may cover only a subset of tokens, so guarantees can be delayed or limited. The provider also pays substantial proving costs, roughly 70–95 times the GPU time of serving the same requests with vLLM.

07

What is a zkSNARK, and how can it let someone verify a computation without seeing the model weights or repeating the computation?

A zkSNARK is a zero-knowledge succinct argument of knowledge. In the article’s description, it is a short certificate that a computation was executed correctly. “Zero-knowledge” means the proof reveals nothing beyond the fact being established; for FlashProve, the verifier does not learn the model’s hidden weights. “Succinct” describes a proof that is far cheaper to verify than recomputing the whole computation.

FlashProve uses this kind of cryptographic proof to check a statement about model inference: the committed weights, given a particular prompt, produced the specified output tokens. The provider creates the proof, and anyone holding the commitment, prompt and reply can check it. The verifier does not need to download the weights or run the model.

The article says FlashProve builds on an interactive oracle proof compiled into a cryptographic proof using hash functions, code proximity tests and lookup arguments. It also says the construction offers post-quantum security. Verification is still not instant: for the reported Maverick case, it takes about 17 seconds on a 24-thread CPU, while proving costs roughly 70–95 times serving GPU time.

This brief was written by AI from the original reporting and checked by other models. Names, figures and quotes come from the source; read it for full context.

Read more in the JupiteX app

Pulse is free. New stories every 4 hours, each one broken into the questions that explain it.

Or read more news on the web