Anthropic’s FlashProve is an open source system that gives cryptographic proof an AI output came from a specific model. See how it wor...
Anthropic’s FlashProve is an open source system that gives cryptographic proof an AI output came from a specific model. See how it works and its limits.
What Anthropic announced
Anthropic is working on an open source system that can verify which AI model produced a given output. The system is called FlashProve, and it was described in a blog post published on Tuesday. The goal is what the researchers call provable inference: a cryptographic proof, in effect a mathematical guarantee, that a particular output came from a particular model. It is meant to let a user confirm that the answer in front of them really came from the model they believe they are using.
That sounds like a small thing, but today nobody outside an AI provider can check it. When you send a prompt to a service and get text back, you have no way to verify which model wrote it. You take the provider's word for it.
Why it is hard to know which model answered
A provider may say it is serving a specific model, but the user only sees the reply. A routing service in the middle could quietly send the request to a cheaper model, or an attacker could tamper with the stream of tokens on its way back. Output quality does not settle the question, because a good answer can come from many models and a bad one can come from the model you paid for.
The researchers describe several situations where this gap matters:
Independent evaluators need to be sure they are testing the model that is actually being served, not a different one.Customers who pay for a specific model through a third-party router want some assurance that the tokens came from it.A compromised server, or a model pretending to be a weaker one, could hide among genuine responses.Regulators may need to confirm that approved models are the only ones being served.Claims about work done by a model are hard to check. If someone says a model audited their code, the only way to be sure is to run the model, and most people have neither the weights nor the compute to do that.
The email signature comparison
The idea resembles cryptographic email signatures, which let a recipient confirm that a message really came from its claimed sender. FlashProve is meant to hold up against impostors who try to pass one model off as another. That includes the case where the impostor is the lab that built and runs the model.
That last point is the unusual one. Most trust systems assume the provider is honest and defend against outsiders. Here the researchers want the guarantee to hold even when the provider is the party with a reason to cheat. In particular, they note that the system could stop an AI company from secretly swapping in a cheaper model to cut costs, or a more expensive model to inflate its performance results.
Checking claims made by third parties
FlashProve could also help verify what other people say about their use of AI. In the researchers' words: "A developer might claim that their software library was scanned for vulnerabilities by a frontier cybersecurity model, or a company might claim that its business plan was given the go-ahead by an appropriate model." They then ask the obvious question: "How can a user verify these claims?"
With a proof attached, the answer would be that you check it. Anyone holding the proof could confirm that a named model produced the stated output, without taking the claimant's word.
How FlashProve works
The system involves two parties. The prover is the model provider. The verifier is anyone who wants to check an output, such as a user, an auditor or a regulator.
Fingerprints published by the lab
To work, the system requires AI labs to publish a fingerprint of each model they release. In technical terms this is a commitment to the model's weights: a short value that pins down one exact set of weights while keeping those weights hidden. Later, an output can be matched against that fingerprint and verified cryptographically.
The fingerprints do not reveal the model's weights, the internal numbers that define how the model behaves. Closed-model makers such as Anthropic and OpenAI keep their weights private, and that is why this matters. A lab could publish fingerprints without giving up its most valuable asset, which means the approach can work with commercial models as well as open ones. In the reported setup, creating a commitment took about 39 minutes per model, and each commitment was good for roughly 16 million requests before it had to be renewed.
Proofs for individual outputs
For a given prompt and the tokens it produced, the provider generates a proof that the committed model yields exactly those tokens. Anyone who holds the commitment, the prompt and the reply can check the proof without ever seeing the weights. The construction is a zero-knowledge proof built from hash functions, and the authors say it offers post-quantum security. The proof reveals nothing about the weights or the internal values the model computed along the way.
Verification on a local device
The system is designed to be lightweight on the checking side, so verification can run on a local device. In the reported tests with a Llama 4 Maverick deployment, a 24-thread CPU verified a proof in about 17 seconds, and the client downloaded a commitment of about 6.5 MB.
What it costs to generate proofs
Proving is far more expensive than checking. In the same tests, proof generation ran at about 110 tokens per second on a single H100 GPU, with about 19 MB of proof data for a 1,024-token request. The researchers put the overhead at roughly 70 to 95 times the GPU time that the vLLM serving software needs for the same prompts.
Several design choices keep that cost under control. The prover's work scales with the roughly 17 billion parameters that are active for each token, not with all 400 billion in the model. Requests are proved in batches after the fact, and the commitment is opened once per batch. Weights are handled one layer segment at a time, so a single 80 GB GPU with about 290 GB of host memory is enough.
Because proofs are produced after the answer is generated, there is a delay before the guarantee arrives. The authors accept that trade: slower proving, with stronger security.
The threat model
The researchers considered four kinds of adversary:
A compromised inference server trying to steal weights or serve malicious responses.
A routing service or provider substituting a different or cheaper model.
A rogue or self-modifying model that presents itself as an authorized, weaker one.
A provider serving unapproved models to avoid regulation.
The protocol aims for the usual properties of this kind of proof. Honest proofs are accepted. Forging a proof for a false statement is infeasible under widely believed cryptographic assumptions, so the verifier does not have to trust the prover. The proof reveals nothing about the weights. And proofs are small and cheap to check.
The design is software only, so its security rests on computational hardness, not on trusted hardware. The authors say an attacker who controls the hardware or the operating system still cannot produce a valid proof of a false statement, and they describe trusted hardware and cryptography as complementary approaches. Their formal results are stated in the random oracle model.
Limitations the researchers acknowledge
This is early work, and the researchers list its limits plainly.Proofs cover contexts of up to 1,024 tokens. Frontier models handle hundreds of thousands or even millions of tokens, so there is a long way to go.
The proof covers an exact integer version of the weights and checks greedy token choices. A floating-point implementation or sampled decoding could diverge at some position, and adversarially designed prompts are not covered by the empirical testing.The system assumes a mixture-of-experts architecture and reveals it. Hiding the architecture is listed as future work.Side-channel attacks, such as measuring timing during proof generation, are out of scope for this release. The proofs also do not show that the hardware is not training on the side.The fast verifier code carries no formal guarantee. The Lean protocol, the paper and the executable code are not guaranteed to match one another.
What was released
Alongside the announcement, the researchers released a detailed technical specification and working code for various elements of the system. Everything is available under an open source license on GitHub. The release includes the blog post, a technical report, a protocol specification, a prover, a fast C++ verifier and a provably correct verifier written in Lean. It also includes Lean proofs of the top-level security theorems and an interactive visualizer to help auditors check the formal statements.
The model weights themselves are not part of the release. Readers who want to reproduce the work have to get Llama 4 Maverick from Hugging Face under Meta's license.
Where the project stands
Research on the system is ongoing, and there are no plans to deploy it at Anthropic or any other lab. The researchers describe the post as a snapshot, not a finished program: "This research post is meant to share intermediate progress, and not a completed research agenda." They add: "We are sharing this explicitly with the goal that others look at what we have done, take it, and improve it."
That framing matters for how to read the news. FlashProve is not a product you can switch on, and no one is promising that it will become one. It is a working demonstration that the problem can be attacked with cryptography, along with an invitation to other researchers to push it further. Open questions include whether the architecture can be hidden as well as the weights, whether context length can grow from 1,024 tokens to full frontier windows, whether proving can happen in line with inference, and whether the integer approach stays faithful to floating-point inference under sampling.
Why this matters for AI transparency
As people lean on AI for coding, research, legal drafts and business decisions, the question of which model actually did the work gets more important. Pricing, performance claims, safety evaluations and regulation all assume that the model named on the label is the model that ran. Until now that assumption has rested on trust. A system that turns it into something checkable, even in a limited form, changes what could be asked of providers and of anyone who cites an AI result.
For now, the practical takeaway is modest. The technique works at a small scale, it is open for anyone to inspect, and it comes from a lab that is willing to be held to it.
Frequently asked questions
What is FlashProve?
FlashProve is an open source research system from Anthropic that aims to provide provable inference: a cryptographic proof that a given AI output came from a specific model.
What does provable inference mean?
It means a mathematical guarantee that an output was produced by a particular model, so a user can confirm the answer came from the model they think they are using.
How is FlashProve like an email signature?
Cryptographic email signatures let a recipient confirm that a message came from its claimed sender. FlashProve does something similar for AI outputs, and it is meant to hold up even against impostors, including the lab that runs the model.
Can it stop a company from swapping in a cheaper model?
That is one of the uses the researchers name. It could prevent an AI company from secretly substituting a cheaper model to cut costs, or a more expensive one to inflate its performance results.
Does a model fingerprint reveal the model's weights?
No. The fingerprint is a commitment that pins down the weights without exposing them, so labs can publish it without giving up their most valuable asset.
Can it work with closed commercial models?
The researchers say it can, because fingerprints do not expose weights, which closed-model makers keep private.
Can I run verification on my own device?
Yes. The system is designed to be lightweight, and verification can run on a local device. In the reported tests, checking a proof took about 17 seconds on a 24-thread CPU.
Is FlashProve available to use?
The specification and working code are public on GitHub under an open source license. Research is ongoing, and there are no plans to deploy it at Anthropic or any other lab.
What are its main limitations?
Proofs currently cover contexts of up to 1,024 tokens, the system assumes a mixture-of-experts architecture and reveals it, side-channel attacks are out of scope, and proving is many times more costly than normal inference.
Reference
Anthropic- https://www.anthropic.com/research/provable-inference
TechCrunch - https://techcrunch.com/2026/11/03/anthropic-is-working-on-a-system-to-prove-ai-models-identity/
Anthropic- https://assets.claude.com/8e1d181a83015078581c92d896757041713f0160.pdf
