Live now · Get your API key

Proof of Logits

How Ambient verifies that a specific model produced a specific output: logit fingerprints, progress markers, and cheap spot-check validation.

Proof of Logits (PoL) is Ambient's mechanism for verified inference: proving that a particular model generated a particular piece of text. For the full protocol treatment, see the Ambient Litepaper.

Logits are fingerprints#

Logits are the raw, unnormalized outputs of a model's last layer, before an activation function like softmax turns them into token probabilities. For every token an LLM generates, it first produces a logit value for each token in its vocabulary.

The combination of all logits produced during a generation is a unique fingerprint of the model's computation at every step, and hashing reduces that fingerprint to a single number.

One nuance matters: identical models on different hardware can produce slightly different floating-point results. Ambient generates hardware-agnostic representations of the logits themselves, so two machines faithfully running the same model produce the same fingerprint.

Per-token commitments and progress markers#

For each generated token, the miner hashes the logits that produced it. The overall proof is a hash over that list of hashes. For tokens n through the final token t:

PoL hash = Hash(Hash(n) ... Hash(t))

A progress marker is the hash of the logits at a chosen point x tokens into the output. With the input, the output, and progress markers in hand, a validator does not need to reproduce the whole generation; it only needs to re-run inference from one token prior up to a given marker.

Validator sampling#

Validation is a four-step spot check:

  1. Miner produces text#

    The miner runs full inference, generating the response and committing logit hashes along the way.

  2. Validator picks a random point#

    A validator selects a random token in the output and requests the miner's "state of thinking" (the logit hash) at that point.

  3. Validator re-runs one token#

    The validator runs a single token of inference on the same context with the same model, producing its own state-of-thinking hash.

  4. Hashes must match#

    If the hashes match, the output is validated. A single token of inference checks an entire generation.

A worked example#

Take a model whose entire vocabulary is four words, and a query whose output is "the rain in Spain". For the first output token, the model produces a logit for each vocabulary word; the largest one wins, and the miner hashes that logit vector. To check the token, a validator runs a single token of inference on the same context and hashes its own logits. If the hashes match, that token is proven.

A four-word vocabulary: Spain (0), the (1), in (2), rain (3). The output is "the rain in Spain". For the first token, the miner's logits are [0, 3.7, -1, 2] across the four vocabulary positions; position 1 ("the") has the highest logit, 3.7, so "the" is generated. The hash of those logits is b9776d7 (illustrative). A validator re-runs a single token of inference on the same context, produces the same logits [0, 3.7, -1, 2], hashes to the same value b9776d7, and the token is verified.

The worked example: the first token "the" wins with a logit of 3.7, and its logit hash (b9776d7, illustrative) is what a validator reproduces from one token of inference.

The economics come from asymmetry: generating a response might cost, say, 4,000 tokens of inference, while validating it costs 1. The scheme is conceptually similar to what Bitcoin does with hashing, except here the computation does useful work. This asymmetry is what keeps verification overhead below 0.1%.

Penalties come out of work credit#

Validation runs as a parallel, ongoing process against a pool of submitted logits. It does not block transaction processing, but invalid work, when detected, results in retrospective slashing of work credit.

That credit is called LStake ("logit stake"): a measure of a node's validated problem-solving contribution over the short and medium term rather than a locked token stake. It takes the place token stake holds in other designs. Leader election and rewards flow from validated useful work performed, and cheating destroys that accumulated standing.

Status on the live network#

The on-chain auction program that carries verification state is active on the testnet, and the API accepts verification-related request flags, but verification artifacts are not yet returned to API callers.

Keep reading#