Dev.to AI 🤖 Ai 👁 0 📖 6 min read

Which model actually answered you? Anthropic's FlashProve makes provable LLM inference practical

Tuesday AI Deep Dive. When you call a model through an API, you get tokens back and a model name in the response. That name is a claim, not evidence. A router could quietly swap in a cheaper model, a compromised server c

Tuesday AI Deep Dive. When you call a model through an API, you get tokens back and a model name in the response. That name is a claim, not evidence. A router could quietly swap in a cheaper model, a compromised server could tamper with the stream, and judging from output quality alone is unreliable.

On Nov 2, 2026, Anthropic's Frontier Red Team (with researchers from EPFL, StarkWare, MIT and others) published FlashProve, an open-source prototype for provable inference: the provider commits to a set of weights, then attaches a cryptographic proof to each response showing that those committed weights produced those exact tokens. The verifier needs no GPU and learns nothing about the weights.

The headline: for Llama 4 Maverick (a 400B-parameter mixture of experts, 4-bit weights), one H100 generates proofs at about 110 tokens/second, each proof is about 19 MB per 1,024-token request, and checking a proof takes about 17 seconds on a 24-thread CPU. The cost is roughly 70-95x the GPU time of serving the same requests with vLLM.

Here is what that means, how it works at a high level, and where it stops.

The problem: "which model answered me?"

Anthropic lists cases where you'd want more than trust:

  • Third-party routing. Clients using a model through a router want assurance the tokens came from the model they paid for.
  • Evaluations. Independent evaluators testing a model before and after release need to know the model they evaluated is the one being served.
  • Tamper detection. An attacker on an inference server (or a more capable model substituting itself for an approved one) could serve malicious responses hidden among genuine ones.
  • Text provenance. Claims like "our library was scanned by a frontier security model" are hard to check; even published chat logs could have been generated by a cheaper model.
  • Pacing and model approval. Regulators could require proof that hardware is serving the claimed, approved model.

The naive fix, re-running the model yourself, needs the private weights and far more compute than a typical user or auditor has.

How it works: commit, then prove

FlashProve uses a zkSNARK (zero-knowledge succinct argument of knowledge): a short certificate that a computation was executed correctly, which reveals nothing beyond that fact and is far cheaper to verify than to recompute.

It runs in two phases:

  1. Offline: commit to the weights. The provider publishes a short fingerprint that pins down one exact set of weights while keeping them hidden. On one H100 this takes about 39 minutes per model, and the commitment is good for about 16 million requests before the provider must commit again. The client downloads about 6.5 MB of commitment data.
  2. Online: prove each response. Given a prompt and output tokens, the prover produces a proof file for the statement "the committed model produces these output tokens when evaluated." Anyone holding the commitment, the prompt and the reply can check it.

The four properties that matter:

Property What it gives you
Completeness An honest proof is accepted
Soundness A proof of a false statement can't be forged (short of breaking widely believed cryptographic assumptions)
Zero-knowledge The verifier learns nothing about the weights, intermediate values, or which experts ran. The architecture is not hidden
Succinctness ~19 MB proof, seconds to check on a CPU, for a run of a ~232 GB quantized model

Under the hood, it follows a well-established recipe: an interactive oracle proof (IOP) compiled into a cryptographic proof using hash functions, built from code proximity tests and lookup arguments. Anthropic notes the construction also offers post-quantum security.

Three engineering choices that made it fast

  • Prove only the experts that ran. In a MoE model each token uses about 17B of the 400B parameters, so prover work per token scales with those ~17B, while the proof still hides which experts were chosen.
  • Prove in batches, after the fact. The prover reads finished text in one parallel pass (like prefill) and opens the weight commitment once per batch instead of once per request. A batch of 24 requests took about 223 seconds.
  • Fit on one GPU. Weights are split into segments and proven one segment of layers at a time, streamed from host memory: one 80 GB GPU with about 290 GB of host memory suffices.

FlashProve proves post-hoc (after inference, possibly for a subset of tokens) rather than in-line. That allows a slower but more secure design, at the cost of recomputation complexity, delayed guarantees, and floating-point non-determinism issues.

Why the numbers are a big deal

The prior-work section is a useful reality check on how fast zkML has moved:

  • ZKML's GPT-2 (117M parameters): about 159 s per token.
  • zkLLM (2024): LLaMA-2-13B at about 2.5 tok/s in a batch.
  • VerInf: the same Llama 4 Maverick at about 0.02 tok/s, with a 93.6 GB proof that took almost a day to verify.
  • Attestable (commercial, not open source at the time of writing): Gemma 4 31B at 53-77 tok/s on one H100.
  • FlashProve: 110 tok/s on Maverick, 19 MB proofs, verified in seconds.

Anthropic's takeaway is that the overhead over native computation is roughly two orders of magnitude, "much less than previously expected."

Trusting the code: Lean proofs

Cryptographic code is brittle, so the team states completeness, soundness and zero-knowledge in the Lean proof assistant and proves them (in the random oracle model). They ship a fast C++ verifier for daily use and a slower Lean verifier that provably accepts only what the soundness theorem accepts.

Two trust gaps remain, and they say so: humans still have to audit that the formal statements match the intent (an interactive visualizer helps), and the fast code isn't formally guaranteed to match the Lean protocol. Soundness depends only on the verifier being correct, which is why a verified verifier is the key piece.

Limitations (read these before getting excited)

  • Greedy decoding on an integer model. The proof covers an exact integer version of the weights under greedy decoding. Sampled decoding or a floating-point implementation can diverge and no longer match the proved computation.
  • 1,024-token contexts. Far shorter than real chat or agent contexts.
  • MoE only, architecture visible. The system relies on the MoE structure and doesn't hide the architecture.
  • Side channels like proving time are out of scope.
  • No formal link between the fast code, the paper and the Lean spec.
  • It's a research prototype. Anthropic also notes that it met its Frontier Safety Roadmap goal for verifying inference traffic through a separate project (signing traffic and recomputing on a trusted server), and has since renamed the goal "inference verification."

What I'd take from this as an AI engineer

  1. Treat the model name in an API response as a claim. If your evals, compliance or security story depends on which model ran, write down how you'd verify it today (provider attestations, trusted hardware, spot re-computation) and where you're simply trusting.
  2. Log what a future verifier would need. Prompt, exact output tokens, model identifier and decoding settings per request. Post-hoc proofs and audits both need the exact input and output.
  3. Pin decoding when provenance matters. Today's proofs assume greedy decoding; sampled outputs won't match.
  4. Watch the cost curve, not just this release. 70-95x GPU overhead is too much to prove every token in production, but enough to prove a sample of traffic or high-stakes outputs, like security scans or eval runs.
  5. Prefer systems where you only have to trust the verifier. That's the design lesson worth copying anywhere: make the small, checkable component the one that carries the guarantee.

References

If a provider gave you a proof for every response, which of your AI workflows would you actually verify first?

📰 Read the original article on Dev.to AI

Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.