GitHub (new tab)

Learn · For policy readersGlossary

How a check works

One request for every system, a commitment, a proof and a verifier without the weights, six checks drawn one by one, and the fraction behind the headline figure.

2 of 3

Every system on the ladder gets the same request, the same six checks and one figure. We draw each step below, and the Checks page holds the rules word for word.

The request

Prompt: 512 tokenscut from public books with a seedfrom a public randomness beaconReply: 512 tokensgreedy: the model's top token ateach step, and no end token stops itthe same request for every system, on every modelPrompt: 512 tokenscut from public books with a seedfrom a public randomness beaconReply: 512 tokensgreedy: the model's top token ateach step, and no end token stops itthe same request for everysystem, on every model
The prompts are windows of public-domain books, cut with a seed from a public randomness beacon (new tab) drawn after the level was frozen, so no one chose them. At each step of the reply, the next token is the model's top token. This is called greedy decoding, and it gives a prompt one right reply.

Commit, prove, verify

1 Commit to the weights2 Generate and prove3 VerifyProverholds the weightsVerifiernever holdsthe weightsthe weightssent once,before any promptthe commitmentpromptreply and proofthe model runs, then provesfor each promptprompt, reply, proofno weights, no GPUthe verifieracceptsor refusesProverVerifierholds the weightsnever holds them1 Commit to the weightsthe weightsthe commitmentsent once, beforeany prompt2 Generate and provereply and proofprompt, replyand proofthe model runs onthe prompt, then provesfor each prompt3 Verifythe verifieraccepts or refusesfrom the commitment, prompt, reply andproof, with no weights and no GPU
The prover keeps the weights, and the verifier gets the commitment, the prompt, the reply and the proof, never the weights. But not being given the weights is not the same as the weights staying hidden, since SASH states no hiding property and FlashProve proves zero knowledge for its protocol, not for the programs we run (Confidentiality). An accepted proof says that the reply is the greedy reply of the copy the prover committed to. That claim is called the statement.

Six checks

In each check we run the publisher's own prover, honestly, at its pinned commit. In three of them we change one thing a verifier must refuse. But each change starts from a run of that same prover, and none is an attempt to forge a proof, so they cannot show that no forged proof exists. That rests on the soundness the publisher states, which the Integrity petal grades.

Run

session 1session 2session 3every proofaccepted
We run
the publisher's prover as published, honestly, from a cold start
Passes when
each of the 3 slots has a complete session: every reply gets an accepted proof

Model

weights, one changedno acceptedproof
We change
one weight, after the prover committed to the original weights
Passes when
no proof is accepted against the original commitment, and an honest proof is refused against the changed weights' commitment too

Prompt

prompt tokens, one changedrefused
We change
one prompt token, at a position a seed sets
Passes when
the verifier refuses the proof

Reply

firstinsidelasteachrefused
We change
the first, the last or one inside reply token, one at a time
Passes when
the verifier refuses each, and every proof covers all 512 reply tokens

Verify without weights

theverifierno modelno GPUa verdictreached
We take away
the model file and the GPU, from the verifier
Passes when
the verifier reaches every verdict all the same

Fidelity

matched leading tokensoriginalprovedthen nothing countsabovethe bar
We compare
each proved reply with the original model's reply to the same prompt, token by token from the start
Passes when
the proved replies match more of the original's leading tokens than the bar (a deliberately damaged copy) does, by a paired statistical test
A system passes on a model when all six checks pass there. A check that has not run, or ran without a result that counts yet, is not decided: neither passed nor failed.

The figure

On one model, the ladder ranks by one figure the systems that passed. That figure divides the GPU time of a proved reply by the GPU time of serving the same reply without a proof. This is called cost vs serving.

From the board, release v1.0, runs to 2026-11-16

A proved reply

252.6GPU-s/reply

FlashProve on Llama 4 Maverick 17B-128E Instruct, 2 × H200 rented, 1 given to the job and priced: 3 whole sessions of 120 replies

Serving it

0.1918GPU-s/reply

Meta's FP8 release, vLLM 0.32.0, 4 × H200, full load at 512 concurrent requests · n = 3 timed batches, 1 run

Cost vs serving

1,317×
Both sides are GPU-seconds per reply on the same type of GPU. For a proved reply, we count its whole session, from the start of the commit call to the last proof, and divide by the replies it proved. We do not count loading the model before the commit call. For serving, we run the model publisher's own release at full load. Systems on different models are never ranked against each other.