How Do You Know Which Model Answered? Notes on FlashProve
你调用一次大模型 API,拿回一段文字,却没有任何办法确认,写下这段文字的究竟是不是你点名的那个模型。路由平台为了压成本悄悄换成更便宜的型号,中间人改动几个 token,供应商拿小模型冒充大模型,这些情形今天几乎都无法当场识破。Anthropic 最近开源的 FlashProve,瞄准的正是这个空白:用 zkSNARK 给每一次推理附上一份可以核验的证明。有意思的是,演示用的模型并不是 Claude,而是 Meta 的 Llama 4 Maverick。下面我按自己的理解,把协议、数据和局限梳理一遍,再补上三处上手时容易踩到的坑。
When you call a model API and get text back, you have no way to confirm that the model you asked for is the one that actually wrote it. A router might quietly swap in a cheaper model to save money, a man in the middle might edit a few tokens, or a provider might pass off a small model as a large one. Today, none of these can be caught on the spot. FlashProve, which Anthropic has just open-sourced, targets exactly this gap by attaching a zkSNARK proof to each inference that anyone can check. The twist is that the demo model is not Claude but Meta’s Llama 4 Maverick. Below I walk through the protocol, the numbers and the limits as I understand them, and add three traps you will likely hit once you start using it.
文章开头用了一个很贴切的类比:和朋友当面说话,你能看见他、听见他、握握手;和模型说话,你手里什么凭证都没有。官方把需要这种保证的人分成三类:做独立评测的人,通过第三方路由调用模型的人,以及流量被人中途劫持的普通用户。他们想要的东西可以一句话说清:一个算力有限、完全不知道权重的用户,能确认某条回答确实出自自己指定的模型。难点有两层。权重是保密的,你拿不到;即便拿到了,想验证一条回答,也得把模型完整跑一遍,这笔算力普通人和评测机构都负担不起。
The announcement opens with an apt analogy. Talking to a friend, you can see him, hear him, shake his hand; talking to a model, you hold no credentials at all. The authors name three groups who need such a guarantee: independent evaluators, people who reach models through third-party routers, and ordinary users whose traffic gets hijacked. The goal fits in one sentence: a user with limited compute and no access to the weights should be able to verify that an answer really came from the model they requested. That is hard for two reasons. The weights are secret, so you cannot get them. And even if you could, checking an answer means re-running the whole model, which most users and evaluation labs cannot afford.
zkSNARK 正是为这类处境设计的。模型方在回答旁边附上一小段证明,大小在几 MB 的量级,用户用一颗普通 CPU 几秒内就能验完。如果回答与指定模型不符,验证会直接失败;而密码学保证证明本身不会泄露权重的任何信息。这类技术在区块链二层网络里已经用了好几年,现在第一次被搬到大模型推理上,而且速度达到了可用的程度。协议本身拆成两段。离线阶段,模型方发布一份权重承诺,它像一枚短指纹,钉死某一组确定的权重,权重本身依然保密。在线阶段,用户给出提示词和输出的 token,模型方产出证明,而证明要说的只有一句话:被承诺的那个模型,在这个提示词上,产出了这些 token。
zkSNARKs were built for exactly this situation. The model operator attaches a small proof, a few megabytes, to the answer, and the user checks it on an ordinary CPU in seconds. If the answer does not match the named model, verification simply fails, while the cryptography ensures the proof reveals nothing about the weights. The technique has run on blockchain layer-2 networks for years; this is the first time it has been brought to model inference at a usable speed. The protocol has two phases. Offline, the operator publishes a weight commitment, a short fingerprint that pins down one specific set of weights while keeping them hidden. Online, the user supplies a prompt and the output tokens, and the operator produces a proof of a single statement: the committed model, on this prompt, produced these tokens.
官方列出了四条性质:完整性,即诚实生成的证明一定会被接受;可靠性,即伪造的陈述造不出有效证明,所以验证者不必信任证明者;零知识,即验证者学不到权重、中间值,甚至不知道每层调用了哪些专家;简洁性,即被证明的是一个 400B 模型在 H100 上跑完整个计算,验证者收到的却只是一个约 19MB 的文件。有一条限定要记牢:承诺藏住的是权重,不是模型架构。原文明确说,隐藏架构不是这套系统的目标。后面讲局限时我会再回到这一点。
The team lists four properties. Completeness: an honestly generated proof is always accepted. Soundness: a false statement cannot produce a valid proof, so the verifier need not trust the prover. Zero knowledge: the verifier learns nothing about the weights, the intermediate values, or even which experts fired in each layer. Succinctness: what is being proven is a 400B model’s full computation on an H100, yet the verifier receives a file of roughly 19MB. One caveat deserves to be remembered: the commitment hides the weights, not the architecture. The write-up says plainly that hiding the architecture is not a goal of the system. I will come back to this when we reach the limitations.
再看实测数字,全部来自官方。测试对象是 Llama 4 Maverick,总参数 400B 的 MoE 模型,每个 token 只激活约 17B 参数,采用公开的 4-bit 权重,量化后约 232GB。Prover 只用一张 H100 加 24 个 CPU 核。离线承诺约 39 分钟,生成一次大约够 1600 万次请求使用。在线阶段,一批 24 个请求耗时约 223 秒,折合 110 tokens/second,每条证明 18.78MB。验证端要轻得多:客户端不需要 GPU,先下载约 6.5MB 的承诺,之后每个请求只收一份证明,24 线程下验证一条约 17 秒,单线程约 21 秒。
Now the numbers, all from the authors. The test model is Llama 4 Maverick, a 400B-parameter MoE that activates about 17B parameters per token, using public 4-bit weights that come to roughly 232GB after quantization. The prover needs just one H100 and 24 CPU cores. The offline commitment takes about 39 minutes, is generated once, and covers around 16 million requests. Online, a batch of 24 requests takes about 223 seconds, which works out to 110 tokens per second, with each proof weighing 18.78MB. Verification is far lighter: no GPU on the client, a one-time download of a roughly 6.5MB commitment, then one proof per request, checked in about 17 seconds on 24 threads or 21 seconds on a single thread.
开销怎么看,要和两个参照物比。第一个是裸推理:官方拿同一模型的 FP8 版本在八张 H100 上跑 vLLM,按每张卡折算,证明一批请求的耗时大约是推理的 72 倍,多轮测试在 66 到 77 倍之间浮动,vLLM 满负载时约 94 倍,也就是原文反复提到的 70 到 95 倍。第二个是同类证明系统:zkLLM 在 2024 年证明 13B 模型,单张 A100 上只有约 2.5 tokens/second;针对同一个 Maverick,VerInf 给出的数字是 1000 个 token 要 14.3 小时,证明 93.6GB,验证接近一天。商业公司 Attestable 报告 31B 稠密模型在单张 H100 上能到 53 至 77 tokens/second,但原文注明截至写作时没有开源库。所以 70 倍应该这样理解:比裸推理贵两个数量级,却比同类证明系统便宜好几个数量级。
The overhead only makes sense against two yardsticks. The first is plain inference. The team ran the FP8 version of the same model on vLLM across eight H100s; normalized per GPU, proving a batch takes about 72 times as long as serving it, with repeated runs ranging from 66 to 77 times and about 94 times at vLLM’s peak load. That is the 70-to-95x figure the write-up keeps repeating. The second yardstick is other proof systems. zkLLM, in 2024, proved a 13B model at roughly 2.5 tokens per second on one A100. For the same Maverick, VerInf reports 14.3 hours for 1,000 tokens, a 93.6GB proof, and verification that takes nearly a day. A commercial vendor, Attestable, reports 53 to 77 tokens per second for a 31B dense model on one H100, though the write-up notes no open-source library existed at the time. So read 70x this way: two orders of magnitude costlier than raw inference, several orders of magnitude cheaper than its peers.
密码学代码出了名地脆弱,所以他们还写了 Lean 形式化证明。理由很坦率:Claude 擅长做优化,却常做出难以评估的决定,系统一大,就没人能看懂它为什么是对的。做法是为安全属性写一份顶层的 Lean 陈述,让机器去检查证明,覆盖完整性、可靠性、零知识,并且都建立在随机预言机模型之下。但形式化只解决了一半,官方自己承认还有两个信任缺口:一是形式化陈述本身要由人来审计,确认它表达的确实是你想要的意思,为此他们提供了一个交互式的可视化工具;二是可执行代码必须和协议对得上。可靠性只依赖验证器,所以他们给出一个可执行的 Lean 验证器,作为 C++ 版的对照。Lean 版很慢,但被证明只会接受可靠性定理允许的东西;日常使用 C++ 版,它没有形式化保证,不过在测试集上与 Lean 版逐条一致。零知识则更现实一些:prover 太昂贵,跑不进 Lean,只能靠人对它做细致审计。
Cryptographic code is notoriously brittle, which is why the team also wrote Lean proofs. Their reasoning is candid: Claude is good at optimization but often makes decisions that are hard to evaluate, and in a large system nobody can see why it is correct. So they wrote a top-level Lean statement of the security properties and let a machine check the proofs, covering completeness, soundness and zero knowledge, all in the random oracle model. Formalization solves only half the problem, and the authors admit two remaining trust gaps. First, humans must audit the formal statement to confirm it says what you actually want, which is why they ship an interactive visualizer. Second, the executable code must match the protocol. Soundness depends only on the verifier, so they provide an executable Lean verifier as a reference for the C++ one. The Lean version is slow but proven to accept only what the soundness theorem allows; the C++ version has no formal guarantee, though it agrees with the Lean one on the test set. Zero knowledge is more pragmatic: the prover is too expensive to run inside Lean, so it relies on careful human audit.
官方列了五条局限,比多数厂商诚实。第一,快速可执行代码没有形式化保证,协议、论文、C++ 实现同源,但不保证完全一致。第二,证明针对贪心解码下的整数模型;浮点实现或采样解码可能在某处偏离,此后就和所证的计算对不上了。第三,架构不隐藏,系统假设对方是 MoE 并借此提效,稠密模型等架构的描述本身可能就含有厂商想保密的东西。第四,侧信道不在范围内,生成证明的耗时这类信息仍可能泄露。第五,上下文只支持 1024 个 token,而聊天场景累积的上下文动辄十万甚至上百万,这一条最难绕开。
The authors list five limitations, more honestly than most vendors would. One: the fast executable code has no formal guarantee; the protocol, paper and C++ code share an origin, but their exact agreement is not promised. Two: the proof covers an integer model under greedy decoding; a floating-point implementation or sampled decoding may diverge at some position, after which it no longer matches the proven computation. Three: the architecture is not hidden; the system assumes an MoE and exploits that for efficiency, and describing a dense or other architecture may itself expose IP a vendor wants to keep secret. Four: side channels are out of scope, so things like proof-generation timing can still leak. Five: context is limited to 1,024 tokens, whereas real chat sessions accumulate hundreds of thousands or even millions. That last one is the hardest to work around.
最后是三处原文没有强调、但上手就会撞上的地方。其一,19MB 的口径前后不一:执行摘要说每 1024 个 token 的请求约 19MB,评测部分却说每条证明只证一个 token、单条 18.78MB。若按后者理解,验满 1024 个 token 就要 1024 条证明,两种读法的下载量相差三个数量级,做容量规划前务必回到技术报告核实。其二,演示模型不是 Claude,而是 Meta 的 Llama 4 Maverick,用的是 Hugging Face 上第三方转换的 4-bit 权重,权重不在发布包内,需要按 Meta 的许可自行下载。其三,它不是路线图上那个九月三十日交付物的兑现方式:原文提到 2026 年 10 月 19 日,目标名从 provable inference 改为 inference verification,并说明那个目标通过另一个独立项目达成,做法是对推理流量签名、在可信服务器上重算。FlashProve 只是同一目标的另一条路。所以如果有人拿这篇文章证明「Claude 已经可以验证」,上面三条足够你当场问回去。
Finally, three things the write-up does not stress but you will run into. First, the 19MB figure is stated inconsistently: the executive summary says roughly 19MB per 1,024-token request, while the evaluation says each proof covers a single token at 18.78MB. Under the latter reading, a full 1,024 tokens means 1,024 proofs, a difference of three orders of magnitude in download size, so check the technical report before any capacity planning. Second, the demo model is not Claude but Meta’s Llama 4 Maverick, run on third-party 4-bit conversions from Hugging Face; the weights are not in the release, and you must download them under Meta’s license. Third, this is not how the September 30 roadmap deliverable was fulfilled. The write-up notes that on October 19, 2026 the goal was renamed from provable inference to inference verification, and says that goal was met through a separate project that signs inference traffic and recomputes it on trusted servers. FlashProve is another road to the same destination. So if someone cites this as proof that “Claude is now verifiable,” those three points are enough to ask them back on the spot.