AI Model Identity Verification: Anthropic's Proof, Without the Hype
Anthropic's FlashProve can cryptographically prove which AI model produced an answer. Here's what it actually proves, and why it's nowhere near your chatbot.

When a chatbot answers you, you have no way to confirm which model actually generated the reply. The company behind it says it’s running its flagship system. You take that on faith, because nothing stops a provider from quietly routing your question to a cheaper, smaller model to save money, while still billing you for the expensive one. AI model identity verification sounds like it should fix that, and a new piece of research from Anthropic takes a real step toward making it possible. It is also, right now, nowhere close to something you’d notice in daily use.
Anthropic, the same lab whose decision to pull its own flagship model offline rattled developers earlier this year, published the work as a research post on November 2, 2026, alongside an open code repository called FlashProve. The headline claim is genuinely new: a way to mathematically prove that a specific set of model weights, and no other, produced a specific set of output tokens. The catch, which Anthropic states plainly in its own post, is that this is “intermediate progress,” not a finished product, and nobody, including Anthropic, has any plan to ship it.
The problem: you can’t check who actually answered
Most people never think about this, because most people never need to. But a few groups do, and for them it’s a real gap. A company building a product on top of a third-party open-weight model wants assurance that the provider is running the model it’s paying for, not a stripped-down substitute that costs the provider less to serve. An independent auditor checking a lab’s safety claims wants proof that the model being tested is the same one the lab actually deploys to customers, not a cleaner version wheeled out for inspection. A business routing its AI traffic through a middleman service, one of the companies that resells access to various providers’ models, wants confirmation that the middleman is honest about which model it’s really forwarding each request to.
None of these are hypothetical anxieties. Model substitution, quietly swapping a cheaper model into a product that’s marketed as running a flagship one, is a known incentive problem: it saves the provider money and the customer usually can’t tell, because models from the same family often write in similar ways. Anthropic’s researchers frame the gap directly: “a user querying a model today cannot check that the responses came from the specific model that a developer claims is responding.” There has been no technical way to settle that question. You could ask the provider nicely. You could not prove it.
How a proof like this actually works, without revealing the model’s weights
This is where FlashProve earns its name, and where the explanation has to stay in plain terms, because the underlying tool is one of the more abstract ideas in computer science made to do something concrete.
The building block is called a zero-knowledge proof. Think of it like this: imagine you want to convince someone you know the combination to a safe, without telling them the combination. A zero-knowledge proof lets you do exactly that; the other person walks away convinced, and still has no idea what the combination is. The specific flavor Anthropic uses is a zkSNARK, a compact, fast-to-check version of that idea (the acronym just means a short proof that can be verified quickly, without back-and-forth). You don’t need the acronym to follow what matters: it’s a proof that’s cheap to check, even though it’s expensive to generate.
FlashProve applies that trick to a model’s weights instead of a safe combination. It works in two phases. First, offline, the model’s full set of weights, the billions of numbers that define exactly how it behaves, gets compressed into a compact cryptographic “commitment,” essentially a tamper-proof fingerprint of that exact model. Anyone can later check an answer against that fingerprint, but the fingerprint itself reveals nothing about the weights it was built from. Second, online, each time the model answers a question, the system generates a proof that this specific committed set of weights, and no other, produced these specific output tokens. A verifier, running on an ordinary computer, checks that proof. If it passes, the verifier can be certain the claimed model produced that answer, without ever seeing the model’s weights or running the model themselves.
Anthropic’s research post — the “Progress on provable inference” write-up where FlashProve and its benchmarks were published.
It’s worth being precise about what this is not, because the two ideas get confused easily. Content watermarking systems, the kind Google’s SynthID uses, work differently: they’re designed to answer “did an AI generate this image or piece of text that’s now circulating online, and roughly which system made it.” FlashProve answers a narrower, more specific question: “did this exact model, this exact set of weights, produce these exact tokens.” One is about tracing a piece of content back to its origin after the fact. The other is about proving a model’s identity at the moment it answers. A deepfake detector and FlashProve are solving adjacent but different problems, and nothing in FlashProve helps trace a stray image found online back to the tool that made it.
The price of the proof, and why it’s steep by design
Anthropic benchmarked FlashProve on Llama 4 Maverick, a large open-weight model with roughly 400 billion parameters, run on a single Nvidia H100 GPU, one of the high-end chips data centers use for AI workloads. The results, from Anthropic’s own post, are the clearest way to understand the trade-off this research makes.
Generating the proof ran at about 110 tokens per second of throughput on the prover’s side. A proof covering a 1024-token window came out to roughly 19 megabytes, and checking that proof took about 17 seconds on an ordinary 24-core computer, no special hardware required on the checking side. Put together, generating a provable answer costs 70 to 95 times more computing time than running the same model normally through a standard inference setup.
That overhead is not a bug to be optimized away next quarter. It is close to the structural cost of doing something this strict: proving, with mathematical certainty, that one specific set of weights and nothing else produced an answer, is a fundamentally harder computational problem than just producing the answer. The 1024-token ceiling compounds the same issue. Current chatbots routinely handle context windows in the hundreds of thousands of tokens; 1024 tokens is roughly a few paragraphs. A proof system that tops out there cannot currently cover a real conversation, a long document, or most of what people actually do with AI models day to day.
So the number to hold onto isn’t “70 to 95 times slower,” full stop; that figure will shift as the benchmark model and hardware change. The durable shape of it is this: proving model identity costs orders of magnitude more than just answering, and that gap is inherent to the approach, not a rough edge Anthropic happened to leave in.
What the proof still doesn’t cover
Anthropic’s team is unusually candid, in its own post, about where the system falls short, and those gaps matter as much as the headline result.
The proof system was built and checked formally, meaning its core logical properties were verified with a proof-assistant tool called Lean, which mathematically confirms a system behaves as claimed rather than just testing it by trial and error. Anthropic’s researchers proved four properties this way: completeness (a correct proof always verifies), soundness (a false claim can never be forged into a passing proof), the zero-knowledge property (the weights, intermediate calculations, and which internal experts got activated all stay hidden from whoever checks the proof), and succinctness (the proof stays compact regardless of how large the underlying computation was). That is a real, rigorous result.
But it applies to the mathematical design, not to the fast C++ program that actually runs the proof generation in practice. The production code itself carries no formal proof of correctness, only the abstract Lean-verified version does. A bug in the fast implementation could, in principle, undermine the guarantee the paper establishes.
Two more limits, stated plainly in Anthropic’s post: the system only proves identity for models using “greedy decoding,” meaning the model always picks its single most likely next word with no randomness. Most deployed chatbots inject some controlled randomness into their replies to sound more natural and varied, and that kind of floating-point randomness diverges from what the proof’s underlying math currently assumes, so it isn’t yet covered. And the time the proof takes to generate could itself act as a side channel, a way information leaks out indirectly: if proof generation time varies in a way tied to the specific weights involved, a patient observer might infer something about those weights just from watching the clock, undercutting part of the point.
Who this is actually for
None of this is aimed at someone opening a chat window tomorrow. The overhead and the token ceiling rule that out on their own. The real audience is narrower and more structural: AI labs that want to audit each other’s claims without handing over their actual model weights, regulators or independent evaluators who need to confirm a deployed model matches what a company submitted for review, and third-party inference services, the businesses that resell access to AI models from various labs, where a customer has a concrete financial reason to doubt they’re getting what they’re paying for.
That last case is the most immediately practical one. If a business buys access to a named model through a reseller, it currently has almost no way to confirm the reseller isn’t quietly substituting something cheaper to pad its margins. A verification system this strict, even at 70 to 95 times the cost, could be worth paying for in high-stakes settings: a financial firm running compliance checks, a government contract specifying an exact model, or a research lab publishing benchmark results that competitors want to independently confirm weren’t run on a different, friendlier version of the model.
FlashProve on GitHub — the open, unmaintained research-prototype repo under Anthropic’s own org.
Anthropic is careful, in its own words, not to oversell where this stands: “this research post is meant to share intermediate progress, and not a completed research agenda.” No lab, Anthropic included, has announced plans to deploy FlashProve. It lives as open research code on GitHub, benchmarked on one model, with the limitations above squarely acknowledged by the people who built it.
Frequently asked questions
Does FlashProve let me check which AI model answered my question in a chatbot?
Not in practice. FlashProve is a research prototype, not a feature in any deployed chatbot. Even if a company adopted it, the current version caps proofs at 1024 tokens and runs 70 to 95 times slower than normal, far too costly and too limited for a real conversation.
Is FlashProve the same kind of technology as AI content watermarking, like Google’s SynthID?
No. Watermarking tools like SynthID mark generated content, such as an image or a block of text, so it can later be traced back to the AI system that likely made it. FlashProve proves something different: that one specific, named set of model weights produced one specific set of output tokens, without revealing those weights.
Why does proving model identity cost so much more computing power than just running the model?
Cryptographically proving a model’s exact weights produced a given output, without revealing those weights, is a mathematically harder problem than generating the output itself. Anthropic’s benchmarks show this costs 70 to 95 times more computing time than standard inference on the same model.
Could a company use FlashProve today to stop a cheaper model from being secretly swapped in?
In principle yes, that is the problem the research targets, but not practically yet. The overhead and the 1024-token limit make it unworkable for everyday use; it is currently closer to a tool for formal audits between labs or regulators than something a business could deploy this year.
Does the model’s internal structure stay completely hidden when a proof is checked?
Almost entirely. The weights, the intermediate calculations, and even which internal “expert” sub-networks were activated for mixture-of-experts models all stay hidden, a property Anthropic’s team formally verified. The one caveat: the time a proof takes to generate could theoretically leak some information too, if that timing varies with the specific weights involved.