Anthropic Open-Sourced FlashProve So You Can Check Which Model Answered You. The Demo Runs Llama 4 Maverick, Not Claude.
Anthropic published its provable-inference research on November 2 and released FlashProve under Apache 2.0: a provider commits to hidden model weights, and every response carries a zero-knowledge-style proof a client can verify on a CPU. The demo numbers are on Llama 4 Maverick at 4-bit, not Claude: about 110 tokens per second of proving on one H100, proofs of about 18.78 MB per 1,024-token request, about 17 seconds to verify on 24 threads, and 70 to 95 times the GPU time of plain vLLM. Lean proves the Lean verifier; the fast C++ and CUDA paths are tested, not proved. There is no Claude product commitment. We read the research post and the repository's proof-scope guide.
By T.W. Ghost
Anthropic published a research post today, November 2, 2026, titled "Progress on provable inference for large language models," and released the code as FlashProve on GitHub under Apache 2.0. The idea: a provider commits to a model's weights without revealing them, and each response comes with a proof, zero-knowledge in style, that the committed model produced it. A client checks the proof on an ordinary CPU. If it holds, the provider did not swap in a cheaper model, quantize behind your back, or route you somewhere else.
That is the problem behind a month of router and intermediary stories, and it is worth saying what Anthropic shipped and what it did not. The demo model is Meta's Llama 4 Maverick, a 400-billion-parameter mixture of experts with about 17 billion active, at 4-bit, with public weights. Claude is not in the demo, and the post makes no commitment to run FlashProve on Claude endpoints. Anthropic calls the work a prototype and "intermediate progress." We read the research post, the FlashProve repository, and its guide to what is and is not proved. Here is what held up.
What FlashProve Does, by Anthropic's Numbers
| FlashProve (November 2, 2026) | |
|---|---|
| License | Apache 2.0, code and Lean proofs and docs |
| Demo model | Llama 4 Maverick, 400B MoE, about 17B active, 4-bit public weights |
| Proving throughput | About 110 tokens per second on a single H100; a batch of 24 requests took the prover about 223 seconds (vendor) |
| Proof size | About 18.78 MB per 1,024-token request (vendor) |
| Verification | About 17 seconds on 24 CPU threads; about 21 seconds single-threaded, including offline-phase checks (vendor) |
| Offline commitment | About 39 minutes; good for about 16 million requests before re-committing (vendor) |
| Cost of proving | About 70 to 95 times the GPU time of running the model on vLLM (vendor) |
| What is machine-proved | Soundness of the Lean verifier, in the random-oracle model, for exact-match claims |
| What is tested, not proved | The C++ verifier and the CUDA prover |
| Claim scope | Exact-match, greedy, integer-arithmetic inference under stated policies; 1,024-token request examples |
| Claude | No commitment; not in the demo |
Not Claude, and not a product. The post is a research artifact with a working prototype attached. Reading it as "Claude replies are now provable" is wrong on both counts.
Honesty has a bill. Seventy to ninety-five times the GPU time, a 19-megabyte attachment per thousand tokens, and seventeen seconds to check. Those are the vendor's own figures for a lab batch of 24; nobody has published what they look like at production load.
Lean proves the Lean verifier. The part that is machine-checked is the slow reference path. The fast paths that would run in practice are tested against the protocol, which is normal engineering and a different kind of assurance. The repository's own guide draws that line, and we follow it rather than a paraphrase.
Why It Matters This Month
The failure FlashProve targets is the one nobody can currently detect: a hosted endpoint quietly serving a different model than the one you paid for. Routers, resellers, and multi-provider gateways are where that risk lives, and it is the same surface OpenAI's intermediary rules, effective November 20, try to govern by contract rather than by proof. We put the two next to each other as editorial context; Anthropic's post does not name that as its motive.
Verified vs Unconfirmed: The Scorecard
| Claim | Verdict |
|---|---|
| Research post dated Nov 2, 2026; FlashProve open-sourced under Apache 2.0 | Verified (Anthropic research; GitHub) |
| Demo on Llama 4 Maverick, 400B MoE, about 17B active, 4-bit | Verified (research post) |
| About 110 tokens per second proving; 223 seconds for 24 requests; 18.78 MB proofs; 17-second verify; 39-minute commit; about 16M requests per commitment; 70 to 95x vLLM | Vendor (Anthropic's measurements) |
| Lean soundness for the Lean verifier; C++ and CUDA paths tested, not proved | Verified (research post; what-is-proved guide) |
| Prototype, "intermediate progress," exact-match greedy scope | Verified (research post) |
| Claude weights committed or FlashProve on Claude endpoints | Unverified (no such claim) |
What To Do
Read the proof-scope guide before the benchmark table; it tells you which claim the math backs and which the tests back.
Do not tell anyone Claude is proving its replies. It is not, and the post does not say it will.
The frontier is elsewhere: the capability race is unaffected by a proof system that costs 70 times the inference. Our model comparison has the current standings side by side; whether you are getting the model on the label is, for now, still a matter of trust.
Sources
- Anthropic: progress on provable inference for large language models
- GitHub: anthropics/FlashProve
- FlashProve guide: what is proved
*Not sure whether the model behind your gateway is the one on the invoice? Take the free 2-minute quiz and get matched. Then read about the policy that tries to solve the same problem on paper: OpenAI's usage policies for intermediaries.*