An event's identity is computed, never assigned: the CBV §8.9 hash, explained for executives

If you run vendor compliance, you already know what a database ID is worth in a dispute: nothing. "Our system says record 48871" persuades nobody, because record 48871 is whatever your system says it is, and your counterparty's system says something else under a different number. The fix is not a better database. It is a different kind of identity — one computed from the record's content, so that the identity itself is evidence.

That identity exists, and it is not ours: CBV 2.0 §8.9, part of GS1's Core Business Vocabulary, defines a standardized hash for EPCIS events. This brief explains what it buys you, in dispute terms, with the demonstration on the page.

Assigned IDs vs. computed identity

An assigned ID is a name somebody's system gave a record. It proves the record exists in that system — nothing more. A computed identity is a digest of the record's own content, produced by a published algorithm: the event's fields are assembled into a canonical string in the order §8.9 prescribes, identifiers are normalized to their GS1 Digital Link form, timestamps are normalized to UTC, and the result is hashed with SHA-256. Same event, same hash — computed by you, by your supplier, by an auditor, by anyone, with no reference to anybody's database.

In a dispute, that difference is the whole ballgame. An assigned ID makes your system the authority, which your counterparty has no reason to accept. A computed identity makes the algorithm the authority, and the algorithm belongs to a standard both sides already operate under.

The demonstration

One receiving event, hashed (identifiers illustrative, from GS1's documentation range):

One transposed digit — the most ordinary of dispute-shaped edits — and the identity breaks loudly. Not a flag in an audit log that someone can also edit; a different identity entirely. The altered record is not a modified version of the original event. It is, verifiably, a different event, and the original's hash proves the original said 96.

The same property catches duplication in the other direction: the same physical event captured twice produces the same hash twice, so double-counted receipts announce themselves.

Graded against someone else's answers

A hash implementation that agrees with itself proves nothing — canonicalization is where implementations quietly diverge, and a divergent hash is worse than none because both sides believe theirs. Ours is gated against the OpenEPCIS reference vectors: published test events with published correct digests, maintained outside our walls. "Our hash is right" means "our output matches the vectors your counterparty's stack also matches" — the claim is graded against someone else's answer key, which is the only grading that means anything. The same discipline governs the rest of the record: conformance means validating against GS1's official pinned schemas, and no conformance attestation has ever been issued — the reproducible check is the claim, in both directions.

What this does to "our system says / your system says"

Today's compliance dispute is two extracts side by side, each authoritative only inside the system that produced it. With computed identity, the question changes shape. Either both parties hold events with matching hashes — in which case the facts are agreed and only interpretation remains — or one party holds an event whose recomputed hash does not match its stated identity, in which case that record has disqualified itself. The standoff becomes a lookup. The full anatomy of that shift, replayed on a model short-ship claim, is the chargeback brief; the reason none of it requires your supplier to join anything is verifiable without joining.

One more layer matters in the room: a hash proves what the record says, and the record must also say who. Every event we keep carries who — the attested observer at the moment of the scan — distinct from capturedBy, the warrantor account standing behind the capture. Content integrity from the hash, attribution from the two grains; a dispute needs both.

The takeaway

Identity computed, never assigned. Duplication detectable, tampering self-evident, agreement possible between parties who trust a published algorithm rather than each other. It is the difference between records and evidence — and in an adversarial process, you are only ever paid for evidence.

Your dispute queue is the natural pilot. Get started — the interview's retail branch asks about the last claim you filed and the evidence you attached, and takes minutes.