Reproducibility

A result you cannot reconstruct is an anecdote. Scellis treats reproducibility as an architectural property rather than a personal habit: identity is a hash, a run is a provenance record, determinism is a tier you declare, and history is never destroyed. Just as deliberately, the platform is precise about what each guarantee means — it names the one you are getting instead of implying a stronger one. This page walks the machinery bottom-up, from content addressing to the exact promise behind “reproducible by URL” — and what you do, stepwise, to make a result citable.

Identity is a hash#

Workflows, models, datasets, and runs are content-addressed: the identity of a committed version is the SHA-256 hash of its bytes, and those bytes can never change — not by policy but by arithmetic, because different bytes are a different hash. Caches obey the same rule: whenever an artifact is read from a local store, its bytes are verified against the hash they claim to carry. A failed verification is not shrugged off as drift; it is corruption, and the artifact is refetched. What a hash names is exactly what you get.

Data, one level deeper#

The same discipline covers data — one level below where most tools stop. Dataset versions are content-addressed, so the same data yields the same hash. And train/val/test splits are themselves versioned, content-addressed artifacts: the exact partition behind a result is recorded by hash and re-resolvable — an artifact you cite, not a convention you half-remember. When a model was evaluated “on the test set”, the record says precisely which bytes that set was.

A run writes its own provenance#

Every run records the full identity of what happened — the program that ran, the plans the engine lowered it to, the data it read, the checkpoints it loaded and produced, the artifacts it wrote, the engine that executed it, and the determinism tier it ran under. Laid out, the record looks like this:

run 812 — committed
  program      sha256:9f2c41ac…   the exact graph that ran
  block_ir     sha256:52aa07c1…   the lowered program
  exec_plan    sha256:cc90e4b2…   dispatches + memory plan
  dataset      sha256:d41c66f8…   a version, never a path
  split        sha256:5a01d9e3…   train/val/test partition
  checkpoint   sha256:8be29a44…   weights · optimizer · RNG state
  artifacts    sha256:77aa1b0d…   metrics table, figures
  engine       1.4.2              the engine that produced it
  tier         prod               determinism, declared
  seed         42                 counter-based RNG

Because each entry is a hash, the record answers questions in both directions. “What produced this artifact?” walks backward from an output to the exact program, data, and engine behind it. “What data trained this model?” walks forward from dataset versions into checkpoints. Experiment tracking falls out for free: an experiment is just provenance — runs plus immutable programs plus dataset versions plus checkpoints — and comparisons are derived views over those records, durable across sessions. How checkpoints themselves are made is part of training in the browser.

Determinism is declared, never defaulted#

Bitwise determinism costs throughput, so Scellis never chooses it for you silently — and never silently takes it away. Every computation declares its determinism tier, and a missing tier fails compilation loudly instead of defaulting.

Randomness itself is engineered for replay: draws come from a counter-based RNG, so a seed reproduces its sequence exactly, with named sub-streams for dropout, shuffling, and augmentation. The RNG state rides inside every checkpoint, so a training run resumed from one continues the precise random sequence it would have produced had it never stopped.

What “reproducible by URL” promises#

The phrase has a precise meaning, and the precision is the point. A committed Scellis link re-resolves the identical committed artifacts — the same bytes, the same program, the same inputs — together with the recorded engine version and determinism tier. That part is unconditional: it holds on any device, and you can walk it end to end in minutes.

Re-execution is a stronger claim, and it is conditional — so the platform names it in two tiers. A run is replayable when it can be re-executed bit-exactly: the debug tier on the same device, or the CPU-reference path anywhere. It is convergent when re-execution agrees within the declared tolerance class — the normal case across different GPUs, whose floating-point hardware genuinely differs. A platform promising bit-equality across arbitrary GPUs would be promising something it cannot verify; Scellis declares the class instead.

Drafts change; commits certify#

A live collaborative session is never hashed — it is a place where things change, and hashing a moving target would mint a false certificate. Committing is the act that mints the citable artifact: from that moment the version is immutable, addressable, and linkable. Collaborate live; cite the commit. The split is deliberate, and it runs through the whole platform.

Sharing covers results, not only recipes. A finished run's outputs — metrics, figures — can be shared as a durable, login-free, citable snapshot URL: whoever opens it re-resolves the identical committed artifacts, provenance record attached. The same committed snapshot renders read-only in a hardened embed, so a write-up or a README can carry the living result instead of a screenshot.

Cite it like literature#

Citation is first-class in both directions: entities carry citations in, and any committed entity or run projects a canonical citation record out — author handle, name, version, content hash, engine version, snapshot URL — rendered to BibTeX, CFF, or CSL from a “Cite this” anchor:

@misc{ada_2026_robust_scaler,
  author       = {ada},
  title        = {robust-scaler (version 3)},
  year         = {2026},
  note         = {content hash sha256:9f2c41ac… · engine 1.4.2 · tier prod},
  howpublished = {Scellis snapshot URL — resolves the committed bytes}
}

The record cites the committed bytes, so the citation cannot drift away from the thing it cites.

History — and the engine — close the loop#

Every document carries a browsable commit history, and any two commits can be diffed — including model architectures, because model graphs are content-addressed and diff like everything else. Restoring never rewrites the past: checking out a prior version lands as a new commit on top of history. Nothing is ever destroyed.

The engine closes the loop. Runs pin the engine_version that produced them; content declares the engine features it needs; and an engine that cannot satisfy a piece of content refuses loudly — a “needs a newer Scellis” diagnostic, never a quiet approximation. On every engine change, a frozen corpus of older work is re-executed so an update cannot silently change old numbers — the same discipline that makes your work outlive our releases. Yesterday's result stays yesterday's result.