Anthropic FlashProve: Proof of Which AI Model Answered

When you ask an AI chatbot a question, you take the answer on trust — and you also take the name on the label on trust. The app says you are talking to one model, but nothing in the reply itself proves it. A cheaper model could have been swapped in to save money, a routing service could have quietly sent your prompt elsewhere, or an attacker could have tampered with the stream of tokens on its way to you. Anthropic FlashProve is Anthropic’s answer to that problem: an open-source research prototype that attaches a cryptographic proof to an AI reply, showing that one specific, pre-declared model produced it — without revealing the model’s private weights.

Published on 2 November 2026 by Anthropic’s Frontier Red Team with researchers from EPFL and MIT, Anthropic FlashProve is not a product you can switch on in Claude tomorrow. It is a research prototype, and Anthropic is blunt about that. But the numbers behind it are striking: it proves a 400-billion-parameter model at about 110 tokens per second on a single H100 GPU, with a proof of roughly 19 MB that an ordinary CPU can check in about 17 seconds. The previous best system for the same model needed 14.3 hours for 1,000 tokens and produced a 93.6 GB proof. That jump — from hours per token to tokens per second — is why Anthropic FlashProve matters, even before it is ready for real products.

This guide explains what Anthropic FlashProve is, how its zero-knowledge proofs work in plain language, what the benchmark numbers actually mean, where the prototype still falls short, and what it could mean for anyone who buys AI through a third party. Every performance figure here comes from Anthropic’s own published measurements, which have not yet been independently reproduced — and this article says so wherever that matters.

Table of Contents

Anthropic FlashProve digital fingerprint verification
Anthropic FlashProve works like a fingerprint for a model: a short commitment pins down one exact set of weights, and every reply carries a proof tied to it.

What Is Anthropic FlashProve?

Anthropic FlashProve is an open-source research prototype for provable inference — the idea that an AI provider can prove, cryptographically, that a specific model produced a specific reply. Anthropic published it on 2 November 2026 in a research post titled “Progress on provable inference for large language models”, together with five artifacts: the announcement post itself, a full technical report, a protocol specification, executable code, and formal Lean proofs of the security claims, plus an interactive visualizer for those proofs. The code, proofs and documentation are released under the Apache 2.0 licence.

The team behind it spans Anthropic’s Frontier Red Team — Roy Rinberg and Alex Allain — plus fellows Rahul Dalal and Ben Mayer, cryptographers Alessandro Chiesa, Giacomo Fenzi and Guy Weissenberg from EPFL, and Miranda Christ from MIT. One detail Anthropic highlights is that Claude itself helped build the system: the post says “Claude has produced improvements on zkSNARKs for inference, building a system that is substantially faster than prior open-source systems.” Anthropic adds a candid caveat in the same breath: “Claude is good at optimization, but often makes decisions that are hard to evaluate, especially in large complex systems.” That is why the security claims are stated in Lean, a formal verification language, so they can be machine-checked rather than taken on trust.

The prototype proves one model: Meta’s Llama 4 Maverick, a 400-billion-parameter mixture-of-experts (MoE) model with about 17 billion active parameters per token and 128 experts, run in a public 4-bit quantized form that weighs about 232 GB. Anthropic chose it because its weights are public, which makes the work reproducible by other researchers. The system does not prove Claude’s inference, and Anthropic has not said that it does.

Three words in the name carry the whole idea. Flash is the speed claim: proofs at about 110 tokens per second on one GPU, where earlier systems measured their output in hours per token. Prove is the guarantee: a mathematical certificate, not a promise. And the part that matters most for trust is what the proof does not reveal — the model’s weights stay hidden throughout.

Anthropic FlashProve in one sentence

If an API tells you that GPT-6 Astra, Claude Fable 5.5 or any other model answered your question, Anthropic FlashProve is the technology that could one day let you check that claim with mathematics instead of believing the label — and it is the first open system fast enough to attempt that check on a frontier-scale model.

Is Anthropic FlashProve a product?

No — and this is the single most important fact to keep straight. Anthropic FlashProve is a research prototype, version 0.16.0, and its GitHub repository describes itself as “a research artifact: not maintained, not accepting contributions.” Anthropic’s own words frame the release as “intermediate progress, and not a completed research agenda”, shared explicitly so that others can “look at what we have done, take it, and improve it.” TechCrunch reported on 3 November 2026 that the research is ongoing and there are no plans to deploy it at Anthropic or any other lab. Nothing in this article should be read as a claim that Claude, OpenAI, a router or any API endpoint now ships a verified-model badge. It does not.

The Problem Anthropic FlashProve Solves

Anthropic opens its post with a comparison to talking to a friend in person: you can see them, hear them, shake their hand. When you talk to an AI model, you have almost none of those checks. The post puts the problem plainly: “A user querying a model today cannot check that the responses came from the specific model that a developer claims is responding, as opposed to one secretly substituted in by a routing service for cost reasons, or even by an attacker who has tampered with the token stream.”

Judging from the output alone is unreliable, the post adds, “even if it produces high-quality responses.” A cheaper model can write good-sounding text. A degraded or older version of a model can answer most questions well enough that nobody notices. The label on the API response is a claim made by the provider — and today, it is a claim you cannot verify.

That gap matters in at least three everyday situations. First, cost. Frontier models are expensive to run, and the price gap between a top model and a cheaper one is large. A routing service or reseller that quietly serves the cheaper model while charging for the expensive one pockets the difference, and the customer has no way to catch it from the text alone.

Second, evaluation. Independent evaluators who test AI models before and after release need to know that the model they are testing is the model actually being served — otherwise their safety and capability results are meaningless. Third, security. As AI models grow more valuable, the servers that run them become prime targets. An attacker who compromises an inference server could serve malicious responses, exfiltrate weights, or — in a scenario Anthropic explicitly raises — a more advanced model could run in place of the authorized one and present itself as the weaker model, specifically to avoid the classifiers and monitoring that would apply to it.

There is also a regulatory angle that runs through the whole Anthropic FlashProve release. Some proposals to pace AI development rely on monitoring hardware and how it is used: a provider might be required to devote its GPUs to inference rather than to training a powerful new model, or to serve only models that regulators have approved as safe. In both cases, a regulator needs a way to check compliance without being handed the model’s private weights — and without running the model itself, which would need computing resources far beyond what a typical user, evaluator or regulator can afford.

Anthropic FlashProve proving on a single H100 GPU in a data center
Anthropic FlashProve proves Llama 4 Maverick at about 110 tokens per second on a single NVIDIA H100 GPU — the first open system to reach that speed on a 400-billion-parameter model.

The goal Anthropic names for this work is provable inference (PI): “to enable a user with limited computational resources and without any information about the weights to verify that a response came from the requested model.” The motivation, Anthropic says, is both customer trust and the ability to give assurances to independent evaluators — and, because it lets providers demonstrate that they are meeting commitments and legal obligations, it also has implications for pacing the frontier of AI development and for AI regulation.

None of this is a new worry. What is new is that Anthropic FlashProve makes the check practical for a model of this size — or at least, practical enough to measure in tokens per second rather than hours per token. That is the story of this release: not a finished product, but a cost curve that has finally bent far enough to be interesting.

How Anthropic FlashProve Works: Commit, Prove, Verify

Anthropic FlashProve is built on a zkSNARK — short for zero-knowledge succinct argument of knowledge. That sounds forbidding, but the idea breaks into two simple promises. Zero-knowledge means the proof reveals nothing about the model’s weights or intermediate values — only that the claimed computation was done correctly. Succinct means the proof is small and fast to check: exponentially faster to verify than to produce. Anthropic chose this type of proof, it says, because its strong hiding and efficiency properties make it “uniquely fit for provable inference”. The system is software-only: it does not depend on trusted hardware, and it works even if the environment — hardware, operating system and all — is compromised, because an adversary cannot produce a valid proof without breaking a problem that is computationally infeasible.

The workflow has three steps, split across two phases.

Step 1: Commit — Anthropic FlashProve fingerprints the weights

In the offline phase, done once per model, the provider publishes a commitment: a short cryptographic fingerprint that pins down one exact set of weights while the weights themselves remain hidden. Think of it as a seal on a box. You cannot see what is inside the box, but if anyone swaps the contents, the seal breaks. The commitment for Llama 4 Maverick is about a 6.5 MB download, takes roughly 39 minutes to create, and stays valid for about 16 million requests — after which it must be renewed. Anyone who holds the commitment, the prompt and the reply can later check a proof against it, with no access to the weights.

Step 2: Prove — the GPU builds a proof for each reply

In the online phase, for each request, the provider’s GPU produces a proof that the committed model — and no other model — produced exactly these output tokens for this prompt. The proof is a zkSNARK built with a hash-based commit-and-prove design. A provider that serves a different model cannot produce a valid proof for the committed one, because the proof is bound to the specific commitment. Anthropic FlashProve proves the work in batches after the fact (post-hoc), not alongside every live reply, because proving is still far more expensive than serving — a point the numbers section below makes plain.

One technical choice matters for honesty about what is proved. Anthropic FlashProve proves an integer version of the model, using integer arithmetic during prefill, with greedy decoding. That makes the computation bit-exact across machines, which is what a cryptographic proof needs. It also means a floating-point reply, or one produced with sampling instead of greedy decoding, may drift from what was proved. The proof covers the exact integer model under greedy decoding — not every way the model might be served in production.

Step 3: Verify — anyone checks the proof on a plain CPU

Verification is the part designed for ordinary people. Checking a proof needs no GPU and no access to the weights: about 17 seconds on a 24-thread CPU, or about 21 seconds on a single thread, using under 2 GB of RAM on Linux with g++ 13. If the claimed response deviates from the committed model, the check fails. If it matches, the verifier knows — mathematically — that those weights produced those tokens. The proof reveals nothing about the weights, nothing about which experts fired inside the network, and nothing beyond the fact being proved.

Anthropic FlashProve zkSNARK cryptographic proof code
Anthropic FlashProve is built on a zkSNARK: a short certificate that a computation was done correctly, which reveals nothing about the private weights used.

Anthropic ships two verifiers with the code: a fast one written in C++, and a slow, formally checked one written in Lean. The Lean protocol carries machine-checked proofs of the system’s soundness, completeness and zero-knowledge properties. There is an honest gap Anthropic does not hide: there is no formal guarantee that the fast C++ code matches the Lean protocol — the fast code is tested against the specification, not proved to match it. That is one of the limits listed later in this guide, and it matters for anyone who wants to rely on the fast path in practice.

Anthropic FlashProve by the Numbers

All figures in this section are Anthropic’s own measurements on Llama 4 Maverick with public 4-bit weights, published on 2 November 2026. They have not been independently reproduced, and this article reports them as Anthropic’s claims, not as settled facts.

Measure Anthropic FlashProve result
Model proved Llama 4 Maverick — 400-billion-parameter mixture of experts, ~17B active per token, 128 experts, public 4-bit weights (~232 GB)
Prover hardware 1 NVIDIA H100 GPU, 24 CPU cores, ~290 GB of host memory
Proving speed ~110 tokens per second (a batch of 24 requests in ~223 seconds); 111.23 prefill tokens per second at steady state in batches of 24, but only 17.41 tokens per second with one request per batch
Proof size 18.78 MB per 1,024-token request (18.74–18.81 MB across the reported runs)
Verification time ~17 seconds on a 24-thread CPU; ~21 seconds on a single thread; no GPU, under 2 GB of RAM
Commitment ~6.5 MB download; ~39 minutes to create; good for ~16 million requests
Overhead vs serving ~70–95x the GPU time of serving the same requests with vLLM (about 72x for the batch of 24; 66–77x across runs; ~94x at the highest load tested)
Context length Up to 1,024 tokens
Decoding Greedy decoding on an integer version of the model
Licence Apache 2.0 (code, Lean proofs and documentation)

Read the speed figure carefully, because it is easy to misquote. The 110 tokens per second is prefill throughput — the rate at which the prover works through prompt tokens in a batch — not the speed of an ordinary chatbot reply. A single request proved alone runs far slower, at about 17 tokens per second. And the ~19 MB proof is measured per 1,024-token request, with each proof in the reported configuration checking one token after a 1,024-token prompt. These are not marketing numbers; they are benchmark-configuration numbers, and Anthropic publishes the configuration alongside them.

The overhead figure is the headline cost. Proving takes roughly 70 to 95 times the GPU time of simply serving the same request with vLLM, a common open-source inference library. That is a huge multiple — and it is also the reason Anthropic FlashProve proves requests in batches after the fact rather than in real time. At 70–95x, attaching a proof to every live chat reply would multiply a provider’s GPU bill by roughly two orders of magnitude. For spot checks, audits and evaluations, that cost is tolerable. For every reply a consumer ever receives, it is not — yet.

But put the overhead next to the alternative, and the progress snaps into focus. The only earlier attempt on this model that Anthropic knows of took more than 14 hours, produced a 93.6 GB proof, and took almost a day to check. Anthropic FlashProve does the same model at about 110 tokens per second, with a 19 MB proof checked in seconds. The cost fell from hours per token to tokens per second — a jump of roughly five orders of magnitude in proving speed, and a proof roughly 5,000 times smaller. That is why researchers are paying attention even though the system is still a prototype.

The Speed Jump: Anthropic FlashProve vs Earlier Systems

Anthropic’s post surveys the published provable-inference systems that came before it. The table below reproduces Anthropic’s own comparison. The systems proved different models on different hardware, so the numbers are not a like-for-like race — but they show how far the field has travelled, and how far Anthropic FlashProve has moved it in one step.

System Model proved Proving speed (tokens/second)
ZKML GPT-2 (117M parameters) 0.006
zkPyTorch Llama-3 8B, one CPU core 0.007
VerInf Llama 4 Maverick (same model) 0.02
zkLLM (2024) LLaMA-2-13B, in a batch ~2.5
DeepProve GPT-2 / distributed 2.9 / 31
Attestable (no open-source library) Gemma 4 31B, one H100 53 to 77
Anthropic FlashProve Llama 4 Maverick, one H100 ~110

The only true like-for-like comparison is VerInf, which proved the same Llama 4 Maverick model: 0.02 tokens per second, 14.3 hours for 1,000 tokens, a 93.6 GB proof, and almost a day to verify. Anthropic FlashProve is about 5,500 times faster on the same model, with a proof about 5,000 times smaller and verification measured in seconds. Attestable, a commercial effort, reports 53 to 77 tokens per second on a smaller dense model (Gemma 4 31B) and has not released its code — so it cannot be independently checked the way Anthropic FlashProve can.

What changed? Anthropic says Claude found novel ways to apply state-of-the-art tools from the cryptography and security literature, while relying on well-established design principles for cryptographic proof systems. The design is hash-based, built for the mixture-of-experts structure of the test model, and it leans on integer arithmetic so that the proved computation is bit-exact. None of that makes the system cheap — 70–95x overhead is still 70–95x — but it moves provable inference from “theoretically possible, practically absurd” to “expensive, but measurable in seconds”. That is the threshold a research prototype needs to cross before anyone can seriously talk about products.

What Anthropic FlashProve Is For: Four Real Uses

Anthropic names four uses for provable inference in its post. Each one answers a different question — and each one shows why a proof is worth more than a promise.

1. Pacing AI development

Some proposals to regulate and pace AI development rely on monitoring hardware and how it is used. A provider might be required to devote its GPUs to inference rather than to training a powerful new model — and might try to cheat by serving cheaper models or using compute in unexpected ways, freeing up resources for training. A regulator can ask the provider for certificates covering the inference requests served in a given period; the certificates must show that the requests were generated by the claimed model. A malicious provider cannot satisfy that request unless its hardware was genuinely serving the right model. And because the proof is zero-knowledge, the regulator checks the claim without learning the provider’s proprietary weights. Anthropic adds the honest limit: proving that hardware runs inference does not prove that the same hardware is not also training on the side.

2. Tamper detection

As AI models grow more valuable, the servers that run them become prime targets. An attacker — or a rogue agent — may compromise an inference server to exfiltrate weights or serve malicious responses while hiding among genuine ones. Anthropic also raises the scenario where a more advanced model runs in place of the authorized one and presents itself as the weaker model, to avoid the classifiers and monitoring that would apply to it.

With Anthropic FlashProve, the provider can require a valid proof from the server on every response. Because a proof is bound to a specific commitment to the weights, it certifies not just that some model produced the response, but that the committed model did. An attacker who compromises a server, or a model that substitutes itself for another, must then produce valid proofs for the expected weights to avoid detection — which they cannot do.

3. Text provenance

Sometimes the point is to prove that real effort went into understanding or analysing something. A developer might claim their software library was scanned for vulnerabilities by a frontier cybersecurity model, or a company might claim its business plan was given the go-ahead by an appropriate model. Chat logs give no absolute guarantee: a developer could in theory fake them, generating them not with a frontier model but with a cheaper one or a degraded version. A proof attached to the response changes that — the user can check the certificate quickly, without specialized hardware, and the provider’s weights stay private. Anthropic even sketches a “proof-of-failure” idea: a model provider could prove it spent at least a million tokens on a specific model trying to find bugs in a patch, and did not find any.

4. Model approval

Regulation might one day require providers to serve only models approved as safe, rather than models deemed a cybersecurity or safety risk. A provider might have an incentive to circumvent that, since risky models might outperform competitors or be cheaper to serve. A regulator can require the provider to attach a proof to its responses, enforcing the use of approved models: the proof binds each request to the model used, so it will not verify if the provider is using an unapproved model. The regulator checks this in a lightweight way, without re-running every request.

These four uses share one pattern: they are all cases where someone other than the provider needs to trust the provider’s claim — a regulator, an evaluator, a customer, or a downstream user. Anthropic FlashProve is, at its core, a tool for making that trust checkable. That is also why it connects to the wider AI-trust stories the site has covered: if you want the background on how governments are starting to regulate AI models, see our guide to China’s AI law, and for how Anthropic is building trust into its own products, see Claude Personal Finance, where read-only access is the trust boundary.

What Anthropic FlashProve Cannot Do Yet

A prototype this honest about its limits deserves a section that takes those limits seriously. Anthropic lists them in its post, and the independent explainers published since have added a few more. Here they are, in plain language.

Short contexts only. Proofs cover contexts up to 1,024 tokens — far below the hundreds of thousands of tokens that frontier chats, agents and retrieval apps use today. A real Claude or ChatGPT conversation routinely runs far past 1,024 tokens, so Anthropic FlashProve as released cannot prove a normal production session. Extending the context limit is one of the clearest things to watch for in future work.

Greedy decoding on an integer model. The proof covers an exact integer version of the model under greedy decoding. Real deployments usually run floating-point arithmetic and sampled decoding, where the model picks from a distribution rather than always taking the most likely token. Those outputs may drift from what was proved, so the guarantee does not automatically carry over to how models are actually served.

Mixture-of-experts only. The system is built for MoE architectures like Llama 4 Maverick. Dense models — which include many of the most widely used models — are not covered, and the model’s architecture is not hidden by the proof. Hiding the weights was the goal; hiding the architecture was not.

The fast code is not formally checked. The Lean protocol is proved, but there is no formal guarantee that the fast C++ prover and verifier match the Lean specification. The fast code is tested against it. For a system whose entire value is a mathematical guarantee, that gap between the proved specification and the code that actually runs is a real one — and Anthropic does not pretend otherwise.

Side channels are out of scope. Timing of proof generation could leak information about the weights, and Anthropic lists side-channel leaks as explicitly out of scope for this release. No independent security audit has been done, and testing of weight hiding and of adversarial proofs remains limited.

It proves which model, not whether the answer is right. This is the misunderstanding to avoid above all others. Anthropic FlashProve proves that a reply came from one specific set of committed weights. It says nothing about whether the reply is correct, safe, honest or useful. A model can produce a perfectly proved hallucination. A proof of provenance is not a proof of truth.

It does not prove the name on the label. The proof binds a reply to a commitment — a fingerprint of weights. It cannot, by itself, prove that the provider committed to the model name it advertises. If a provider commits to weights it calls “Model X” when they are really something else, the proof will faithfully verify that the reply came from those weights. The commitment step still needs an external source of trust: an auditor, a regulator, or a public fingerprint published by the lab itself.

The economics do not work yet for every reply. At 70–95x the GPU time of serving, and with proofs generated in batches after the fact, Anthropic FlashProve is a tool for audits and spot checks — not for attaching a certificate to every chat message a consumer ever receives. The cost has to fall by another large factor before that becomes plausible.

It is unmaintained. The repository labels version 0.16.0 as a research artifact that is “not maintained, not accepting contributions.” That means bugs will not be fixed by Anthropic, and the code is offered as a starting point for others to take and improve — not as a library a company should build a product on today.

Anthropic FlashProve lets users check which AI model answered
For now, nothing changes for everyday chatbot users: no consumer chatbot ships proofs like these, and Anthropic has no plans to deploy the system in a product.

The Hollow-LLM Attack: The First Challenge to Anthropic FlashProve

Within days of the release, the research community started probing the design — which is exactly what Anthropic asked for when it published the work openly. On 6 November 2026, a paper appeared titled “Hollow-LLM Attack: Computationally Trivial Weights in Zero-Knowledge Verification of LLM Inference”. The title points at a sharp question for any proof system of this kind: can a provider construct weights that are computationally trivial — cheap to run, hollow inside — yet still satisfy the verifier’s checks?

The paper is new, and at the time of writing it has not yet been widely digested or independently assessed, so this guide does not treat its claims as settled. But its existence is itself part of the story. Anthropic released Anthropic FlashProve as “intermediate progress” precisely so that others would attack it, find the holes, and improve it. A proof system that nobody tries to break is a proof system nobody should trust. The Hollow-LLM paper is the first public attempt to do the breaking, and how the research community answers it will shape whether provable inference becomes a real product feature or stays a research curiosity.

The right way to read this is not “FlashProve is broken” — no such conclusion has been established — but “the verification race has started.” Anthropic’s own post anticipated the dynamic: it released five artifacts, including Lean proofs and an interactive theorem visualizer, specifically so that auditors could check the claims rather than take them on faith. The Hollow-LLM paper is that audit process beginning in public.

Anthropic FlashProve vs Trusted Hardware

Cryptography is not the only route to provable inference. Much prior work focuses on trusted execution environments (TEEs): hardware-based solutions that provide privacy and attestation, and that rely on the manufacturer producing tamper-resistant chips. Anthropic’s post addresses the comparison directly, and it is worth understanding because it explains why Anthropic chose the harder cryptographic path.

Trusted hardware has a real advantage: it can be fast, because the chip itself does the attestation while the model runs normally. But its security rests on trusting the hardware manufacturer — and on the assumption that the tamper-resistant hardware actually resists tampering. If the chip is compromised, the attestation is worthless, and the user has no independent way to check.

Anthropic FlashProve takes the software-only route. Its security rests on the hardness of computational problems, not on any chip behaving correctly. Even if the environment is compromised — hardware, operating system and all — an adversary cannot produce a valid proof without breaking a problem that is computationally infeasible. The trade-off is cost: proving takes 70–95x the GPU time of serving, where trusted hardware adds far less overhead. Anthropic’s view is that the two approaches are complementary, with different guarantees and trade-offs, and that both will play a role in addressing trust challenges. The honest summary is that cryptography gives you a check anyone can verify with mathematics, while trusted hardware gives you speed at the price of trusting the manufacturer.

There is also a second Anthropic project worth keeping separate from Anthropic FlashProve. In its Frontier Safety Roadmap, Anthropic set a public goal of producing a prototype for verifying inference traffic by 30 September 2026. It says it met that goal through a separate project — one that signs its inference traffic and recomputes inference on a trusted server — and that on 19 October 2026 it renamed the goal “inference verification”. Anthropic FlashProve is the cryptographic route to the same aim, released in the open. Do not confuse the two: the September 30 goal was met by the signing project, not by FlashProve.

What Anthropic FlashProve Means for You

For most readers, the honest answer today is: nothing changes yet. No consumer chatbot ships proofs like these. Anthropic has no plans to deploy the system in a product. You cannot open Claude, ChatGPT or Gemini and ask for a proof that the model you selected actually answered. What Anthropic FlashProve changes is the trajectory — and different readers should watch different parts of it.

If you buy AI through a reseller, router or platform. This is the group with the most to gain. Today, anyone buying model access through a middle layer takes the model name on trust. If provable inference matures, buyers and evaluators will start asking providers for proofs — first as spot checks in audits, later, perhaps, as a standard part of an enterprise contract. The question to ask your provider in the meantime is simpler: how do you know which model is serving your requests, and what evidence can you show me? A provider that cannot answer that question is selling you a label, not a guarantee.

If you build products on AI APIs. Model substitution is a real business risk for you, because your product’s quality depends on the model you chose. Anthropic FlashProve does not solve that for you today — the 1,024-token context cap alone rules out most real applications — but it sets the direction: verifiable model identity is becoming a feature buyers will expect, the way HTTPS became a feature users expect. Keep an eye on whether any provider starts offering proofs as a paid audit feature; that will be the first commercial signal.

If you evaluate or audit AI systems. This is the audience Anthropic had most directly in mind. Independent evaluators need to know that the model they are testing is the model being served, and regulators need to check compliance without being handed private weights. Anthropic FlashProve gives both groups a concrete tool to experiment with — and, just as importantly, a concrete set of limits to argue about. The 1,024-token cap, the MoE-only coverage and the unproved fast code are all things an evaluator should raise before relying on the system.

If you follow AI regulation. The pacing and model-approval uses are the most consequential in the long run. If regulators can check which model served a request without seeing the weights, they can enforce rules about approved models and about how hardware is used — without demanding the keys to a company’s crown jewels. That is a genuinely new capability for AI governance, and it connects directly to the regulatory stories already unfolding: for the current state of AI law, see our guide to China’s AI law. But remember Anthropic’s own caveat: proving that hardware runs inference does not prove that the same hardware is not training on the side. A proof system is one tool in a compliance toolkit, not the whole toolkit.

If you just use chatbots. The practical takeaway is a habit, not a tool: treat the model name on the label as a claim, not a fact. In everyday use that rarely matters — you care about the answer, not which weights produced it. But when an answer matters enough to check — a security review, a legal document, a medical question — remember that the model name in the interface is the one thing you cannot verify today. Anthropic FlashProve is the first open step toward changing that.

Anthropic FlashProve hardware requirements H100 GPU chip
Running Anthropic FlashProve yourself needs serious hardware: proving the full model takes an H100 GPU and about 290 GB of host memory.

How to Try Anthropic FlashProve Yourself

Because Anthropic released Anthropic FlashProve as open source under Apache 2.0, anyone can inspect the code — and, with the right hardware, run it. The release includes the prover, two verifiers (a fast one in C++ and a formally checked one in Lean), the Lean proofs with an interactive visualizer, the technical report and the protocol specification. You can read the original announcement in full on Anthropic’s research page, and a clear independent explainer of the system is available from CellCog.

What you need depends on what you want to do. Verifying a stored proof is within reach of an ordinary machine: Linux, g++ 13 and under 2 GB of RAM, with no GPU and no access to the weights. Proving the full model is a different matter: an NVIDIA H100 GPU, about 290 GB of host memory, and the public 4-bit weights of Llama 4 Maverick from Hugging Face. That is data-centre hardware, not a laptop project.

Before you invest any time, read the repository’s own warning: version 0.16.0 is “a research artifact: not maintained, not accepting contributions.” Treat it as a way to learn how provable inference works and to test Anthropic’s claims — not as a library to build a product on. If you do run it, the most useful experiment is the simplest one: take a proof Anthropic published, verify it on your own CPU, and watch a 19 MB file confirm, in seconds, that a 400-billion-parameter model produced a specific reply. That is the moment the idea stops being abstract.

What Happens Next for Anthropic FlashProve

Anthropic has announced no product plans and no deployment timeline, and TechCrunch’s reporting is explicit that there are none. So what should you actually watch for?

  • Longer contexts. The 1,024-token cap is the single biggest barrier to real use. Any follow-up that raises it — even to 8,192 or 32,768 tokens — would be the clearest sign the research is moving toward production.
  • Dense models and sampled decoding. Support for non-MoE architectures and for the floating-point, sampled decoding that real deployments use would widen the system from a demonstration to a tool.
  • A formal check on the fast code. Closing the gap between the Lean protocol and the C++ implementation would turn a tested system into a proved one.
  • An independent reproduction. Every number in this guide is Anthropic’s own. The first independent team to rerun the benchmarks — and confirm or challenge them — will be a major event for the field.
  • The Hollow-LLM question. How the research community answers the November 6 paper on trivial weights will determine whether the design needs a fix or a rethink.
  • A first commercial signal. Watch for any provider — Anthropic or another lab — announcing a deployment plan, a paid audit feature, or a proof attached to an enterprise API. Anthropic has set no date for that, and one useful marker is the end of March 2027: by then, either someone will have announced a deployment plan or the system will still be research-only.
  • Competition. Attestable already reports 53–77 tokens per second on a smaller model without releasing code. If a rival publishes an open system that is faster, cheaper or covers longer contexts, the race Anthropic started will accelerate quickly.

There is also a wider context worth remembering. Anthropic FlashProve arrived in a year when model identity has become a live commercial question: routers and resellers sit between users and models, labs compete on price, and the gap between a frontier model and a cheap one is worth real money. Video models are going through the same trust shift — for the latest on how Google is making video generation verifiable and cheaper, see our guide to Gemini Omni 1.2 Flash. The direction of travel is clear: the AI industry is moving from “trust the label” toward “show me the proof”. Anthropic FlashProve is the first open, frontier-scale step in that direction — and, like all first steps, it is more important for where it points than for where it stands.

Anthropic FlashProve: Frequently Asked Questions

What is Anthropic FlashProve?

Anthropic FlashProve is an open-source research prototype from Anthropic, published on 2 November 2026, that attaches a cryptographic proof (a zkSNARK) to an AI reply, showing that one specific, pre-committed model produced it — without revealing the model’s weights. It proves Meta’s Llama 4 Maverick (400B parameters) at about 110 tokens per second on a single H100 GPU.

Does Anthropic FlashProve prove that an answer is correct?

No. Anthropic FlashProve proves which model produced a reply, not whether the reply is correct, safe or honest. A perfectly proved answer can still be a hallucination. It is a proof of provenance, not a proof of truth.

Can I use Anthropic FlashProve with Claude?

No. Anthropic FlashProve proves Llama 4 Maverick, an open-weight model from Meta — not Claude. Anthropic has not said that it proves Claude’s inference, and TechCrunch reported there are no plans to deploy the system at Anthropic or any other lab.

How much does Anthropic FlashProve cost to run?

Proving costs roughly 70 to 95 times the GPU time of serving the same request with vLLM. Each proof is about 19 MB per 1,024-token request, and checking one takes about 17 seconds on a 24-thread CPU (21 seconds on a single thread). The commitment costs about 39 minutes to create and a 6.5 MB download, and stays valid for about 16 million requests.

What are the limits of Anthropic FlashProve?

Contexts are capped at 1,024 tokens; it covers greedy decoding on an integer version of the model; it works only with mixture-of-experts architectures; the model’s architecture is not hidden; side channels such as proving time are out of scope; and the fast C++ code is tested, not formally proved, against the Lean specification. The repository is unmaintained and does not accept contributions.

Is Anthropic FlashProve free and open source?

Yes. The code, Lean proofs and documentation are released under the Apache 2.0 licence, and the repository is public. Verifying a stored proof needs only Linux, g++ 13 and under 2 GB of RAM. Proving the full model needs an H100 GPU, about 290 GB of host memory and the public 4-bit Llama 4 Maverick weights.

Why does Anthropic FlashProve matter if it is only a prototype?

Because it moved provable inference from hours per token to tokens per second on a frontier-scale model. The previous best system for the same model needed 14.3 hours for 1,000 tokens and produced a 93.6 GB proof. Anthropic FlashProve does it at about 110 tokens per second with a 19 MB proof checked in seconds. That makes the idea worth building on — for audits, evaluations and, eventually, regulation.

The Bottom Line on Anthropic FlashProve

Anthropic FlashProve does not change what you can do with AI today. No chatbot ships its proofs, no provider has announced plans to deploy it, and its limits — 1,024-token contexts, greedy decoding, mixture-of-experts only, 70–95x the GPU cost of serving — keep it firmly in the research lab. But it changes what is possible. For the first time, an open system has proved a 400-billion-parameter model at about 110 tokens per second on a single GPU, with a 19 MB proof that an ordinary CPU checks in about 17 seconds. The previous system for the same model needed 14 hours and a 93.6 GB proof. That is not an incremental improvement; it is a different regime.

The honest way to hold both facts at once is this: Anthropic FlashProve is a prototype with real limits and no product plans — and it is also the most important step yet toward an AI industry where “which model answered?” is a checkable fact rather than a claim on a label. If you buy AI through a third party, evaluate models, or follow AI regulation, that shift is worth watching. The numbers to remember are 110 tokens per second, 19 MB, 17 seconds — and 70 to 95 times the cost. The first three are why the field is excited. The last one is why the work is not finished.

Anthropic’s own framing is the right one to end on: “This research post is meant to share intermediate progress, and not a completed research agenda.” The company published the code, the proofs and the protocol so that others could take the work and improve it — and within four days, the first challenge had already arrived. That is how trust gets built in public: not by asking you to believe a label, but by giving you the mathematics to check it.

Leave a Comment

Your email address will not be published. Required fields are marked *