"Ten identities, and each one exists to prevent exactly one specific mistake."
The Whole Ladder, One Rung at a Time
Recall's pipeline has roughly ten identity layers, and the temptation is to see them as over-engineering. They're not. Each one exists because there is a specific, real confusion it prevents — a specific way the pipeline would do the wrong thing if that layer collapsed into the one above it. Read the ladder as a list of mistakes-that-can't-happen:
- Video (video_id) — prevents duplicate logical archive rows for the same slot.
- Observed media (cheap_fingerprint) — prevents treating changed bytes as the old file.
- Archive execution (execution hash) — prevents queueing the same transcode/transcribe execution twice.
- Source content (source_sha256) — prevents confusing 'same path' with 'same bytes.'
- Audio proxy (source hash + proxy config) — prevents rebuilding identical audio chunks.
- Paid provider call (chunk hash + provider config) — prevents paying twice for identical evidence.
- Transcript run (video + source + provider config + proxy config) — prevents duplicating accepted raw evidence.
- Release (run id + content hash) — prevents duplicating the same projected transcript.
- Summary (release + type + provider + model) — prevents repeating an identical summary artifact.
- Title (summary id on the video) — prevents presenting a title derived from stale summary evidence.
Why Each Layer Earns Its Place
Notice that the layers are not redundant copies of one hash — they answer different questions at different granularities. The paid-call identity and the transcript-run identity look similar, but one is scoped to a single audio chunk (so you don't pay twice for that chunk) and the other to a whole video's evidence (so you don't duplicate the accepted run). Collapse them and you either pay per-video when you meant per-chunk, or you dedupe per-chunk when you meant per-video. Each layer is the exact granularity at which one specific kind of sameness needs to be recognized.
This is a Merkle-tree-shaped idea: identities at different levels, each summarizing what's below it, so a change anywhere is detectable at the right layer without re-checking everything. Data-deduplication systems do the same — they hash at chunk boundaries so an unchanged region is recognized cheaply while a changed one is isolated precisely. Recall's ten layers are that principle applied to a transcription pipeline: every distinct notion of 'the same' gets its own identity, at its own granularity.
The Transferable Rule
You will almost never need exactly ten layers. But you will constantly face the underlying decision, and here's the rule to carry: whenever you reach for a 'done' or 'exists already' check, ask 'the same at which level?' Same logical entity? Same observed version? Same exact bytes? Same derived output under the same settings? Each 'yes, but' in that questioning is a hint that you need another identity layer. The number of layers is just the number of distinct kinds of sameness your system actually has to tell apart — no more, and never fewer.