Introduction
I have a habit I picked up from years of building WordPress sites for clients: when something important happens on a server, I want a log I can check later. Not a promise. A receipt. If a plugin says it sent an email, I want the mail log. If a host says a backup ran, I want the backup file with a timestamp on it.
AI has never given me that receipt. When I call an API and a response comes back, I have exactly one reason to believe it came from the model I paid for: the company on the other end says so. The response itself carries no proof. A cheaper model could have answered. A routing layer could have swapped models mid-request. A middleman could have tampered with the output. I would never know, because there is nothing in the response to check.
This week Anthropic published something that tries to fix exactly that. It is called FlashProve, an open-source research prototype for what researchers call "provable inference." It attaches a cryptographic proof to an AI response, showing that the response really came from a specific model — and it matters because AI is now doing customer support, code review, and medical summaries, anywhere "which model did this?" carries legal and financial weight.
The Problem Nobody Likes to Talk About
Let me be honest about how AI APIs work today, because the trust gap is bigger than most of us admit.
When you pay for a frontier model, you are paying for capability. The most expensive models cost more per token because they are supposed to be smarter, safer, and more reliable. But once your request leaves your server, the model is a black box. You send a prompt, you get text back, and the text looks the same whether it came from the flagship model or a distilled model a tenth of the size running on cheaper hardware.
This matters in three places I keep running into.
First, cost. If you are paying frontier prices, a provider or routing service that quietly swaps in a cheaper model is overcharging you for every single token. You would have no way to catch it, because the output would still look plausible.
Second, compliance. A bank, a hospital, or a law firm that leans on AI output needs an audit trail for which model produced a given decision. "Trust us" is not an audit trail.
Third, security. If an attacker can sit between you and the model and alter responses, or a compromised service can claim a trusted frontier model did work it never touched, the whole chain of trust breaks — and AI agents are now managing WordPress sites, editing content, and touching customer data.
The honest answer until now has been that we just trusted the provider. That worked while AI was a novelty. It does not work now that AI output is showing up in contracts, support tickets, and production systems.
What FlashProve Actually Does
FlashProve is Anthropic's answer, and the idea is elegant in a way I appreciate as a developer. It does not ask you to trust the provider more. It gives you something you can check yourself.
Here is the short version. A lab publishes a fingerprint of a model's weights — a cryptographic commitment — without revealing the weights themselves. The weights stay secret, which is the whole point for a commercial lab. Then, when the model generates a response, the system produces a proof alongside it. Anyone who has the fingerprint can verify that proof later and confirm that this response came from that specific model.
Think of it like a wax seal on a letter. You do not need to see the signet ring to check the seal — you just need to know what the genuine seal looks like. That check could expose a provider quietly swapping in a cheaper model, an attacker tampering with responses in transit, or false claims that a task was handled by a frontier model when it was not.
Anthropic says Claude helped build the system, which is a nice detail — an AI model helping to build the tool that proves which AI model did the work. The code is open source under the Apache 2.0 licence, and it is formally verified in Lean, a proof assistant that lets mathematicians check the correctness of the underlying cryptography with machine precision.
The Numbers: Fast, But Not Cheap
The reason FlashProve is news, and not just another research paper, is speed. Previous open-source efforts at provable inference were so slow that they were effectively theoretical. Anthropic's prototype is dramatically faster.
In tests on Llama 4 Maverick, a 400-billion-parameter model, a single H100 GPU generated proofs at about 110 tokens per second. Each proof is roughly 19 MB, and verifying it takes only seconds on an ordinary CPU — no GPU needed on the checking side. That asymmetry is exactly how a trust system should work: hard to fake, easy to verify.
But the costs are still brutal. Proving uses about 70 to 95 times the GPU time of running the model normally. For every dollar of compute you spend generating an answer, you would spend seventy to ninety-five dollars proving that the answer came from the model you think it did. That is the kind of overhead that kills a product idea in a budget meeting.
The other limits are just as real. The prototype only covers contexts up to 1,024 tokens, which is short — many real conversations are far longer. It relies on a mixture-of-experts architecture and a specific decoding method, so it does not generalize to every model design. And it does not hide a model's architecture, which some labs would consider a leak in itself.
Anthropic is refreshingly honest about all of this. They describe the work as intermediate progress, not a finished product. TechCrunch reports there are no plans to deploy it at Anthropic or any other lab right now.
Why This Matters Even Though You Cannot Use It Yet
I have seen a lot of research announcements that I filed away and forgot. I am not filing this one away, for a simple reason: the direction of travel is clear, and the direction is toward verification becoming a requirement rather than a luxury.
Think about where AI is heading. We covered on this blog last month how WordPress is moving toward native AI agent support, with agent access becoming a standard sign-in flow. The same week FlashProve landed, OpenAI rewrote its Model Spec — the public document that says how its models should behave — around five core values: faithfulness to human intent, harm minimization, honesty and transparency, human agency, and care. OpenAI dropped most of its style guidance and admitted its current models do not yet fully reflect the document.
Read those two stories together and a pattern appears. The industry is moving from rules to values, and from chatbots to agents that act on your behalf. In that world, "which model did this, and can you prove it?" stops being a research question. It becomes a procurement question, then a compliance question.
Imagine you are a WordPress agency owner in two years. A client asks why their site's AI support agent gave a customer the wrong refund policy. You need to show which model answered and that the answer was not tampered with. Or you run a WooCommerce store and an AI agent places orders on a customer's behalf, and the customer disputes a charge. The receipt that says "this exact model produced this exact response" is suddenly worth more than the model itself.
FlashProve does not solve that today — the 1,024-token limit alone rules out most real conversations. But the speed jump is the thing to watch. The hard problem in provable inference was always performance, and Anthropic just showed a 400-billion-parameter model can be proven at 110 tokens per second on a single GPU. That turns a theoretical idea into an engineering roadmap.
What I Would Do With This Today
You cannot deploy FlashProve in production, and you should not try. But there are practical things this announcement should change about how you build with AI right now.
First, log which model served each response. If you are calling an AI API from your site or your plugin, store the model name, the timestamp, and the request ID alongside the output. You cannot verify that information cryptographically yet, but having the log is the habit that makes verification possible later.
Second, stop treating model identity as a detail. When you choose a model for a customer-facing feature, write down why you chose it and what would change if it were swapped for a cheaper one. If the answer is "nothing, the output would look the same," you are probably overpaying. If the answer is "everything, the customer is paying for the best model," then you have just identified a trust gap that proof systems like FlashProve will eventually fill.
Third, watch the standards. Provable inference only works if labs agree on how fingerprints are published and how proofs are checked. Anthropic open-sourcing the code under Apache 2.0 is a step toward that. If other labs adopt compatible approaches, verification becomes a feature you can demand in a contract rather than a research demo you read about.
Fourth, be careful with agents and permissions. A proof that a model did something does not help you if you never should have let it do that thing in the first place. Verification and authorization are two different problems, and you need both.
Conclusion
FlashProve is not a product. It is a proof that a product like this is possible, and that the performance gap is closing fast. Anthropic built a system that can cryptographically tie an AI response to a specific model, proved it works on a 400-billion-parameter model at 110 tokens per second, and released the code for anyone to inspect. The costs are still too high and the context is still too short, but the direction is unmistakable.
For years, trusting an AI provider meant trusting a brand. FlashProve points to a future where trusting an AI provider means checking a proof. I will be watching what happens next, and logging which model answers my requests in the meantime. You should too.
FAQ
What is Anthropic FlashProve?
FlashProve is an open-source research prototype from Anthropic for "provable inference." It attaches a cryptographic proof to an AI response, letting anyone verify that the response really came from a specific model, without the lab revealing the model's weights.
How does FlashProve verify which model produced a response?
A lab publishes a cryptographic fingerprint of a model's weights. When the model generates a response, the system produces a proof alongside it. Anyone with the fingerprint can check the proof later — similar to checking a wax seal without seeing the signet ring.
How fast is FlashProve?
In Anthropic's tests on Llama 4 Maverick, a 400-billion-parameter model, one H100 GPU generated proofs at about 110 tokens per second. Each proof is roughly 19 MB and takes only seconds to verify on an ordinary CPU. However, generating a proof uses about 70 to 95 times the GPU time of running the model normally.
What are FlashProve's limitations?
It only covers contexts up to 1,024 tokens, relies on a mixture-of-experts architecture and a specific decoding method, and does not hide a model's architecture. Anthropic calls it intermediate progress, and there are no plans to deploy it yet.
Can I use FlashProve in my WordPress site or app today?
Not yet. It is a research prototype, not a production tool. The practical step today is to log which model serves each AI response in your site or plugin, so you have an audit trail ready when verification tools like this become usable.
Why does provable inference matter for developers?
Because AI output is now used in support tickets, code, summaries, and decisions with real consequences. A proof that a specific model produced a specific response protects you against silent model swaps, tampered responses, and false claims — and gives auditors and enterprise buyers something they can actually check.
