Skip to main content

Fingerprints and reproducibility

Every question about a production model eventually becomes forensic: which data trained the thing that produced this score? Tessera's answer is content-addressing. Every immutable artifact — a schema-contract version, a leakage-policy version, a dataset build, an encoder set, a model checkpoint, an evaluation report, a promotion bundle — is identified by a fingerprint: the sha256 of its canonical form.

Canonical JSON, or it doesn't count​

A fingerprint is only useful if the same content always hashes the same way. Canonical serialization makes that true: dictionary keys sorted, compact separators, floats serialized to 17 significant digits with NaN/Infinity rejected, strings NFC-normalized with line endings collapsed. No wall-clock timestamps, no random values, no dictionary-order accidents ever enter a fingerprinted payload — and training randomness is seeded, with the seed recorded inside the fingerprinted run config.

Bundles pin everything​

When a model has no blocking promotion gate — and any advisory quality failures are explicitly acknowledged — it can be packaged as a promotion bundle. The bundle pins — records the fingerprint of — every input that shaped it:

PromotionBundle
├── model checkpoint        (checkpoint_fingerprint)
├── dataset build           (dataset_fingerprint)
│   ├── event-store snapshot cursor set
│   ├── schema contract     (contract version fingerprint)
│   ├── leakage policy      (policy version fingerprint)
│   └── label definitions   (label set fingerprints)
├── encoder set             (encoders_fingerprint)
├── tokenizer version
└── evaluation report       (eval_report_fingerprint)

Activating a bundle on a slot re-verifies every pinned fingerprint against storage, byte for byte. Mismatch means refuse to serve. A corrupted checkpoint, a manually "fixed" encoder file, a swapped eval report — activation aborts rather than serve a model whose provenance no longer checks out. The only way around it is an explicit, recorded override (allow_mismatch: true plus a reason), which lands in the audit trail.

What this buys you​

  • Exact reproducibility. The same dataset fingerprint, model config and seed reproduce the same training outcome within tight tolerance — re-running an experiment means re-pointing at fingerprints, not reconstructing folklore.
  • Meaningful diffs. Two bundles differ? Their pins tell you exactly what changed: contract v3 → v4, or a new label set, or only the seed.
  • Auditable scores. Every score response carries model_fingerprint, bundle_id and event_cursor — from a single served score you can walk back to the exact bytes of everything that produced it. You will see these fields in the quickstart's final step.
  • Honest caches. Identical dataset requests dedupe by fingerprint; a re-POST of the same build returns the existing artifact instead of burning compute.

This is why the sample dataset you download in the quickstart ships with a manifest.json carrying its own fingerprint: two generations of it are byte-identical, and the docs pipeline verifies that on every build.