Research

Anthropic open-sources FlashProve for zero-knowledge proofs of AI inference

Anthropic published a way for a language model to prove it produced a specific answer from specific weights, without handing anyone those weights. The demo works. It's also slow and limited to short prompts, and the paper says so out loud.

Daniel HarrisDaniel Harris
Heat: 1,050
Abstract indigo shield with a check mark linked to a chain of hexagons

Anthropic published a way for a language model to prove it produced a specific answer from specific weights, without handing anyone those weights. The demo works. It's also slow and limited to short prompts, and the paper says so out loud.

What FlashProve proves, in plain terms

When you send a prompt to a hosted model, you're trusting the operator. A routing service could quietly pass your request to a cheaper model and bill you for the expensive one. Someone with access to the serving stack could edit the token stream on the way out.

FlashProve is aimed at that gap. It lets the model's operator publish a proof that a committed set of weights produced exactly these output tokens for this prompt. The proof reveals nothing about the weights themselves, which is the part that makes it usable by a company that won't open its model.

The machinery is a zkSNARK, a cryptographic receipt that convinces a checker a computation happened without revealing the inputs. Anthropic published the code, a protocol spec, a technical report and Lean proofs on November 3, all under Apache 2.0. The code ships a prover, a fast C++ verifier and a slower Lean one.

How the FlashProve proof splits into two phases

The first phase is offline. Anthropic commits to the weights once and produces a short fingerprint, about 6.5 MB. That run takes roughly 39 minutes. The result then covers about 16 million requests.

The second phase happens per request, and it's where the cost lands: each prompt gets its own proof, generated by a prover and checked by a verifier that runs on plain hardware.

Splitting the work this way is the reason the design is interesting. The expensive part is a one-time setup. The recurring part is per-query proving, and that's the number everyone will argue about.

The Llama 4 Maverick numbers Anthropic measured

The test model was Llama 4 Maverick, a 400B-parameter mixture-of-experts model with about 17B parameters active per token, running on public 4-bit weights on a single H100 with 24 CPU cores.

Proving ran at about 110 tokens per second. A proof for a 1,024-token request came out around 19 MB.

Verification is cheaper and needs no GPU at all: it took 17 seconds on 24 threads, or 21 seconds when restricted to a single one.

Then the overhead. Proving a batch took about 72 times longer per GPU than vLLM serving the same batch. Across runs the gap ranged from 66 to 77 times, and at the highest load tested it reached about 94 times.

That's the honest headline: this isn't free, and the bill is paid in compute.

Why zkSNARK inference matters if you rent a model

Three audiences show up in the post. Routing services, because a marketplace that resells inference has an obvious incentive to substitute models. Attackers, because a tampered token stream is hard to spot from the outside. Regulators, because a rule that only approved models may be served is unenforceable if nobody can check which model answered.

Anthropic also floats a reverse use, a "proof of failure" that could show a model spent at least some number of tokens hunting for bugs and found none. That turns a negative result into something a lab could publish.

Whether any of this becomes standard is a different question. A proof only helps if the party you distrust is the one being asked to produce it.

So who runs the verifier?

How FlashProve compares with earlier zero-knowledge AI work

Anthropic's own comparison puts the numbers in context. VerInf needed about 14.3 hours to prove 1,000 tokens on a DGX Spark, with a proof of 93.6 GB. zkLLM proved a 13B model at roughly 2.5 tokens per second on an A100.

A commercial system called Attestable reports 53 to 77 tokens per second on a dense 31B model, and it hasn't released open code.

So FlashProve beats the research baseline by a wide margin, and it lands roughly where the one commercial option sits, on a smaller dense model and different hardware. Different hardware, different architectures and different threat models make a clean ranking impossible.

The limits Anthropic lists for provable inference

Anthropic is unusually direct about what the prototype can't do, and the list is long.

It covers an integer version of the weights under greedy decoding. Replies that sample or that run in floating point can drift and stop matching the proof. The method assumes a mixture-of-experts architecture and doesn't hide that architecture. Side-channel attacks sit outside the scope. Context is capped at 1,024 tokens, which is short for most real conversations.

The fast C++ verifier isn't formally verified. The Lean verifier is, and it's slow.

What Anthropic's Lean proofs cover, and what they leave open

The security properties are machine-checked in Lean: completeness, soundness and zero knowledge. That's a stronger claim than most research code ships with.

Two gaps remain, and the team names both. The formal statements still need human auditing, since a machine can only check that a proof follows from a statement, not that the statement says what you meant.

The second gap is older than this paper: showing that the compiled code matches the specification is a separate problem, and a formally verified model of a protocol doesn't amount to a formally verified implementation.

What comes next for Anthropic provable inference

Anthropic's Frontier Safety Roadmap set a public goal of a provable-inference prototype by September 30, 2026. The company says it met that goal through a different project, one that signs inference traffic and recomputes it on a trusted server.

FlashProve is a second route, and a harder one, because it needs no trusted hardware at all. The next milestone to watch is context length. At 1,024 tokens, a proof covers a paragraph. Chat needs more, and so does anything agentic.

Share This Story

Sources

Related AI News

Concentric spiral curves crossed by a vertical line with bright points pinned along it
Research

An Anthropic Researcher Says Claude Proved the Riemann Hypothesis. Stanford Answered Within Hours

A researcher says he and Claude produced a proof of the hardest problem in mathematics, and the code compiles. Verification is a different job, and it has barely started.

Heat: 1,860
A stack of agent nodes linked by a path to a server rack, with a keyhole and a breach mark on the rack
Research

An AI Agent Found a Zero-Day and Owned a University Server in 11 Minutes

An operator gave the agents one goal and no method. They found an undocumented flaw in medical imaging software and owned the server, after 148 failed actions somewhere else.

Heat: 1,520
A funnel carrying small token blocks from one model box to another, with a shield plate blocking part of the flow
Research

OpenAI Cut Reasoning Theft From 54% to 0.2%. The Rest Is an Industry Problem.

OpenAI published the before-and-after numbers for its latest safeguards and they look like a fix. The same post explains why the fix has to be repeated every week, by everyone.

Heat: 1,420
A green chip grid with one highlighted cell and a jagged signal line beside the words Blackwell fingerprints
Research

Blackwell fingerprints in six Chinese models: what a checkpoint can prove

Dek: PyTorch fills billions of empty weights with random numbers, and the GPU doing the filling leaves a mark in the finished file. Someone checked six Chinese checkpoints and found newer silicon than the rules allow.

Heat: 1,250