HN

Comments (68)

• Menu

  neuwirth
  This is built on VerInf, work that I did as a MARS fellow. They ripped everything down to the choice of 400B Maverick from us with very little attribution. Cool, I guess... https://github.com/jamespetrie/verinf
• thereader12
  It feels kinda yucky reading through a document that spends half the time saying how this great for our regulatory capture efforts and how they won't have to show anyone the wieghts. It's not even a bad thing, you want to know you are using what you think you are, but they are advertising the side effects as features.
• vessenes
  I've been writing about the need for provable inference (and training) on and off for a number of years; this is welcome news and a good start, and a significant improvement on prior zk results.The problems of inference proof for a closed model provider are more difficult than an open model provider -- you can get a probabilistic proof much more cheaply out of four independent inference providers running the same non-batched prompt than this 90-100x compute hit.Anthropic and others also have a significant problem with these proofs in that they have a lot of incentive internally to have some portions of the pre-prompt secret; I haven't read this newest scheme closely enough to determine if they have a way to hide parts of the prompt with the proof. But if they don't, they are almost certainly not going to want to send these proofs out in the general case.Last, I'll take this moment to soapbox and say for the researchers out there -- provable inference is nice. Provable training corpus information would be spectacular. It would be very, very, very nice to provide a set of model weights and a proof that they had only been trained on a dataset. To be clear, this is a really hard problem, but it would change fundamentally what levels of trust we could have about a given set of weights.
• Menu

  nemo1618
  For open-weight models, provable inference is trivial: just redo the computation! This is much faster, cheaper, and doesn't require any fancy cryptography, just deterministic inference (which, if you read carefully, the ZKP approach needs too). See https://lukechampine.com/repligraphsOf course, it's unlikely that we'll get open-weight models from OpenAI or Anthropic any time soon. That means we have to choose between a) fancy ZKPs, b) signed responses, or c) comparing results from multiple inference providers.Whatever method ends up being used, it's clear to me that some form of provable inference is inevitable. People haven't caught on to its more significant applications, but they will. (This post touches upon one of them: model-driven audits.) Think about it: we can prove that a particular mind authored a particular artifact. That's never been possible before! You can't prove that Melville wrote Moby Dick, for example; but you can prove that Claude wrote a poem, or that Gemini approved a pull request, or that GPT got a particular score on some eval. This is a more powerful primitive than a cryptographic signature.
• gopalv
  > In both cases the question is the same: how can a company be sure of which weights are actually running on its servers?> the resulting commitment is good for about 16 million requests, after which the provider has to commit again.> The client downloads the commitment, ~6.5 MB in all, and then one proof per request. Checking a proof takes 17 seconds on 24 threads (and 21 seconds on a single thread), including the offline phase's checkI know they mentioned $ETH in the technical report, but this is exactly the mechanic for a crypto currency Proof-of-Work which is expensive by design.When they announced it, I was hoping for a 5% overhead validation that the model that served you is really Fable and not Opus.The quantization bit caught me out, because we saw the boundary crossing from good-context-size to bad is so sharp it feels like longer context requests are sent to quantized models to make more room for more KV-Cache. This would expose those sorts of tricks people can play to have the same GPU do better on short context benchmarks and gracefully degrade on long context.At work, we did a bit of digging[1] into exactly why BaseTen, Fireworks and Together serve Inkling weights differently, we suspected the issue was a combination of how you do disaggregated prefill (+streaming) and quantization for longer context tasks.[1] - https://isotopes.ai/blog/everyone-is-selling-the-same-model-...
• Menu

  vintagedave
  I've read that providers like those you find on OpenRouter can sometimes route to other models; this would catch that.But I've also heard, as complete rumour, sometimes some named models perform significantly worse on some hosts and the theory is they're running quantized, without that being published. Would this solve that? The post mentions proving a set of weights, but not how those are represented? What would stop a host using true weights for generating the signature, while running on quantized versions?> We prove an exact integer version of the published weights, and a proof asserts that each checked token is that model’s greedy choice. A reply from a floating-point implementation, or sampled decoding, could depart at some position...So, no...?
• Menu

  ajb
  Interesting, but I'm not sure the property it attests is one we care about that much. Or rather, it's one you'd expect Anthropic not to tell you it needs to prove. I mean it tells you that you're not being stiffed by Anthropic using a cheaper model and that they haven't literally been MiTMd, but that's kind of table stakes. Otherwise it's not telling you much useful. It's not telling you that your data hasn't been exfiltrated, and it's not telling you any useful property of the answer.
• Menu

  xpct
  > As models become capable of improving and deploying themselves ... how can a company be sure of which weights are actually running on its servers?I find this a bit odd and backwards. Why do we choose not to make the deployment code to be robust, but instead to observe the model inference as proven? This moves unobservability layer to the system that collects the proofs. Given the assumption that code is fluid and LLMs are rewriting it often, how can we know it isn't being abused against the observer?Goes without saying, it's also disappointing that this has nothing to do with making the model inference observable for consumers.
• EliKarasik
  We're working on provable inference at Attestable (https://attestable.com/) - our solution is one of the comparisons provided.We've published initial performance metrics in August of 87 t/s on Muse Glimmer 30B (a dense model) - orders of magnitude faster than existing OS projects. Antropic's FlashProve supports only a fully integer model with a small context length (significantly hurting evals).There is significant progress since then, and we'll publish more results soon.
• Menu

  grey-area
  At first I thought this was work on the far more important problem of proving that LLM output is provable and correct given some source of truth. But it's about the trivial problem of 'proving' which model is being used.Who will find this useful? I can't really think of a use for it, because if you don't trust the provider of your models, it's game over really - you're already giving them all sorts of private data, you're relying on their service, you have to trust them to some extent and this doesn't really help because unless you are running the service yourself. Seems like more of an internal problem for Anthropic than something that would interest others.
• Menu

  stevemk14ebr
  This obviously an attempt at being able to say a response came from an anthropic model vs say some other model via a model router. As for me, I will keep using my model router, I don't care to be charged more for a name brand. I don't care about the brand at all, it's a commodity.
• ronfriedhaber
  Attestable does great work on the subject: https://attestable.com/blog/proving-llms-scale
• Menu

  fscaramuzza
  My PhD is on auditability of AI systems, and we are exactly working on the engineering of ZKP in this context. I can confirm through our industry partner (AI Assurance and auditing), that black box auditing is indeed a huge problem for them, and snarks have shown their potential in this context. It's great to see Anthropic confirming our early results.
• Menu

  wcoenen
  > The goal of provable inference (PI) is to enable a user with limited computational resources and without any information about the weights to verify that a response came from the requested modelIsn't this already solved by watermarking?This page said they would provide an API to check whether a given text has the watermark for a Claude model:https://www.anthropic.com/news/claude-text-watermark
• ygouzerh
  Are they doing that because they are scared that Moonshot might route queries to Claude?
• Menu

  jmort
  What are the tradeoffs of an approach like this vs confidential computing primitives and attesting everything from untampered hardware all the way up to the served request? It seems more performant. Is it simply that they would have to reveal too much?
• anonymous908213
  > A user querying a model today cannot check that the responses came from the specific model that a developer claims is respondingIndeed, I wonder what kind of developer would make users worry about that...? Funny PR stunt coming from a company that was in the news for silently routing ML-related requests to an inferior model.https://fortune.com/2026/06/10/anthropic-accu-claude-fable-5...> Unlike Fable’s other restrictions, such as around cybersecurity and biology, which openly redirect users to a less powerful model with a visible notification, the system card emphasized that this is “not visible to the user.” The model still responds, but uses “interventions to limit Claude’s effectiveness” without telling the user it’s doing so.
• dnnehgf
  i guess the idea here is that if the end user cannot discriminate based on capability above some threshold, the premium that you can charge for more capable models either disappears entirely (if the end user is the principal source of truth on quality) or gets arbitraged down (if the end user is merely an agent of the principal source of truth on quality). to maintain that premium in perpetuity, you just need (a) trusted benchmarking services that can distinguish between premium and generic, and then (b) a way to prove to the end user that a given output is premium.so this solves for (b).
• with
  isn't model substitution a vendor accountability thing? and token tampering, is that not infra security?do either of these need 70-95x the GPU time in "zksnark" proofs?
• ex-aws-dude
  > Some proposals to regulate and pace AI development rely on monitoring hardware and how it is used. For example, a provider might be required to devote its hardware to inference rather than to training a powerful new model. The provider might try to cheat by serving cheaper models or using compute in an unexpected way, freeing up resources for training. How can a regulator reliably ensure that the hardware is used for inference?Is this even a real problem? Forcing a company to only do inference?Sounds like Anthropic's dream scenario