Serving State · numeric.lineage · cache.epoch · entropy.custody
You set temperature to zero, send the same request twice, and get two different answers. The vendor tells you nothing changed. Nobody can check that, because the things that did change live inside the serving stack: how many other requests shared the batch, which cached blocks got reused, what draw the sampler took. These three receipts fix each one, so the answer you got can be tied to the machine state that produced it.
Patent pending
Two teams argue about a number a model produced. One says the model chose it. The other says the machine did. Today that argument has no referee, because the evidence that would settle it is thrown away microseconds after the answer is returned.
Here is the part people miss. Floating point addition is not associative. Add the same numbers in a different order and you can get a different sum. Inside a serving stack that order is chosen by how busy the machine is, so the batch you happened to land in can move the last bits of every score. If two candidate answers were close, the machine picks the winner.
We measured this directly, in process, over float32. Same inputs, same values, and the only thing changed was the width of the reduction tile.
| What we measured | Result |
|---|---|
| Trials where tile width alone changed the sum | 200 of 200 |
| Spread, median | 22 ulp |
| Spread, p95 | 151 ulp |
| Spread, maximum | 2838 ulp |
| Smallest candidate separation a narrow tile could not overturn | 2048 ulp |
Read the last row again. Two candidates closer together than that were not decided by the weights. They were decided by how loaded the server was. This is an arithmetic benchmark run locally. No provider was contacted and no provider is named by it.
Numeric Lineage · numeric.lineage · 25 gates
Send the same request set at two different batch occupancy levels and measure how far the emitted tokens diverge. The divergence bound is fixed by digest before the first request goes out, so it cannot be widened afterward to make a bad run look fine. The record carries the accumulator width, the reduction split count and the reduction order for each level, and the route change and the withheld settlement are recomputed from the measurement rather than taken on trust.
Cache Epoch · cache.epoch · 27 gates
A build epoch over the weight build, the kernel build and the numeric configuration is an input to the block key itself, not a label stapled on beside it. Every reused block is checked against the epoch of the weight set actually resident in memory when the request was admitted, and any block from a different epoch is unmapped and recomputed before decoding passes its prefix. Residency age and cross epoch reads are recomputed from the record.
Entropy Custody · entropy.custody · 25 gates
You commit a secret before decoding starts. Every stochastic token is then selected by locating a value derived from your secret inside the cumulative interval of the distribution the server reported for that position. If a keystream position is missing or already consumed, the decoder halts rather than quietly drawing again. The server cannot pick the draw that suits it, because it never held the draw.
Each receipt runs its gates in a fixed order and stops at the first refusal. The gates below are the load bearing ones, the checks that recompute a value or a claimed effect rather than reading a field back.
| Receipt | Gates | Recomputed, not trusted |
|---|---|---|
numeric.lineage | 25 | SALT_PRECOMMITMENT, DIVERGENCE_BOUND_PRECOMMITTED, PRECOMMITMENT_ORDER, DIVERGENCE_RECOMPUTE, ROUTE_CHANGE_EFFECTED, SETTLEMENT_REFUSAL_EFFECTED, SETTLEMENT_POSITION_RECOMPUTE, VERDICT_RECOMPUTE |
cache.epoch | 27 | SALT_PRECOMMITMENT, COMMITMENT_RECOMPUTE, EPOCH_IDENTIFIER_RECOMPUTE, BLOCK_KEY_RECOMPUTE, RESIDENCY_AGE_RECOMPUTE, EPOCH_RELATION_RECOMPUTE, CROSS_EPOCH_READ_COUNT_RECOMPUTE, VERDICT_RECOMPUTE |
entropy.custody | 25 | SALT_PRECOMMITMENT, PRECOMMITMENT_ORDER, KEYSTREAM_DERIVATION_RECOMPUTE, INPUT_DIGEST_RECOMPUTE, INTERVAL_MEMBERSHIP_RESIDUAL_RECOMPUTE, MEMBERSHIP_RECOMPUTE, DRAW_CONSUMPTION_COUNT_RECOMPUTE, DECODER_HALT_EFFECTED, VERDICT_RECOMPUTE |
Every magnitude in the verdict path is exact integer arithmetic over decimal strings. There is no floating point anywhere in the decision, which matters when the thing being judged is a floating point defect.
Each block below is carried inside the signed body of the receipt itself, and a
BOUNDARY_CONSTANT gate refuses any receipt whose boundary text has been edited.
numeric.lineage receipt does not sayNumeric Lineage record. Attests that an identical request set declaring a temperature of zero was transmitted to one named serving endpoint at two or more batch occupancy levels induced by the measuring gateway, that the bitwise divergence of the emitted token sequence across those levels was measured against a divergence bound whose digest was fixed before the first measured request was transmitted, that the accumulator width identifier, the reduction split count, and the reduction order identifier reported for each level are recorded as signed fields, and that the recorded serving set change and the recorded withholding of settlement authorization were recomputed from the measurement rather than supplied. It does not attest that any emitted token sequence is correct, does not attest the numeric precision of the weights, does not attest a quantization level, does not attest the identity of the model served, and does not attest that any nondeterminism observed arose from batch occupancy rather than from another source the endpoint may have introduced.
cache.epoch receipt does not sayCache Epoch record. Attests that a build epoch identifier derived over a named weight build, a named kernel build, and a named numeric configuration was an input to the block key under which each listed key and value block was addressed, that the epoch recorded for each block was compared against the epoch of the weight set resident in the named high bandwidth memory region at admission of this request, that every block whose recorded epoch differed was unmapped from this request's block table and recomputed under the resident weight set before decode proceeded past its prefix range, and that the residency age of each reused block and the cross epoch read count were recomputed from the recorded monotonic readings rather than supplied. It does not attest that the response is correct, does not attest anything about latency, does not attest which other parties read any block, does not attest that the resident weight set is the weight set the requesting party expected, and does not attest that any block outside the listed candidate hits was evaluated.
entropy.custody receipt does not sayEntropy Custody record. Attests that every stochastic token in the recorded sequence was selected by locating a keystream value derived from a secret committed by the requesting party before decoding began within the cumulative interval structure of a distribution the serving process reported for that position, that the count of keystream positions consumed by the sampler was recomputed from the sampler counter and the emitted length, that the interval membership residual at each emitted position was recomputed from the reported cumulative lower bound and the consumed keystream value, and that where a keystream position was absent or already marked consumed the decoder halted without emitting a further token. It does not attest that the reported distribution is the true distribution of any model, does not attest the identity of the model served, does not attest that the output is correct or useful, and does not attest that the serving process ran any particular model rather than a different model capable of reporting a self consistent distribution.
| Route | What it does |
|---|---|
| POST /v1/mint/numeric-lineage | Issue a numeric.lineage receipt over evidence you measured |
| POST /v1/verify/numeric-lineage | Verify one, 25 gates in fixed order |
| POST /v1/mint/cache-epoch | Issue a cache.epoch receipt over evidence you measured |
| POST /v1/verify/cache-epoch | Verify one, 27 gates in fixed order |
| POST /v1/mint/entropy-custody | Issue a entropy.custody receipt over evidence you measured |
| POST /v1/verify/entropy-custody | Verify one, 25 gates in fixed order |
These three sit under the answer, at the layer where the machine and the model meet. Put their receipts in a transparency checkpoint and you also prove the receipt was in the set at a moment an independent timestamp authority signed. The full map of typed receipts and how they compose is in the proof architecture.