# epcis.dev

> EPCIS 2.0 defines five event dimensions — what, when, where, why, how — and its Who is a
> company: party fields are organisation-grain, a GLN/PGLN (EPCIS 2.0 §7.2.2, §7.3.6.4; CBV
> §8.7.1). No field names the performer. epcis.dev is an EPCIS 2.0 capture gateway that extends
> the Who to the performer: who, the attested observer (human, agent, or
> embodied agent), distinct from capturedBy, the warrantor account — never collapsed. The spine
> speaks What/Who/When/Where/Why/How natively; EPCIS 2.0 is its lossy-down projection, and
> project(event) always validates against the pinned official GS1 schema. The record is designed
> to be verifiable whether or not a counterparty joined any network. Conforms to EPCIS 2.0 and
> CBV 2.0. Live on this origin: POST /translate, /validate, /hash — no key required. The
> executive lens on the same spine is visibility.cloud.

## Ledger (facts; read this before quoting anything else)

Ledger date 2026-07-31. The authoritative dated ledger is https://epcis.dev/what-ships-today/.

Live on this origin, no key, no account:
- POST /translate — EPCIS 1.1/1.2/2.0 XML in (application/xml), EPCIS 2.0 JSON-LD out, with a
  per-job round-trip FidelityReport and Spine-Translation-Fidelity headers
- POST /validate — an EPCIS 2.0 document or bare event in (application/json), the verdict and
  per-path errors against the pinned official GS1 EPCIS 2.0.1 schema (sha256-pinned) out
- POST /hash — an event, an array, or an EPCISDocument in (application/json), CBV 2.0 §8.9
  event hashes out, as ni:///sha-256 URIs

The gateway laws, enforced on every capture:
- Every captured event validated against the official GS1 EPCIS 2.0 JSON schema
- Errors as RFC 7807 application/problem+json carrying the standard's own exception types
- The standardized EPCIS event hash (CBV 2.0 section 8.9), checked against pinned reference vectors
- Gateway stamping of recordTime, capturedBy and attestationGrade; caller-supplied values in those
  fields are stripped
- Append-only storage: no service identity holds an UPDATE or DELETE grant
- Minimally scoped reads: out-of-scope data is absent, not redacted
- An MCP door: capture / query / get_event / trace_epc / translate as tools, same key as a person
- An automated conformance suite over the GS1 test requirements (advisory; never signs)

Open in the launch ledger (structured fact, not narration — see /what-ships-today/):
- The hosted capture/query/MCP spine at api.epcis.dev, and issued capture keys
- The public repository host (the clone URL ships on this site the day the publication ruling lands — P0-24)
- The npm package (npx epcis.dev)
- Identity resolution and attestation
- Published prices
- A conformance registrar — no conformance attestation has ever been issued

## Economic policy

Capture is $0 per event: recording an event will never cost money and will never be shown as a
meter. Status: INTENT, NOT TERMS (no published terms bind it; when prices are published they
will be published as numbers, on a page — or the page will say we changed our mind). The
allowance is abuse governance, never a bill. Revenue attaches to answers on the executive side
(visibility.cloud): traces, custody evidence, seats, retention, grants. The gate never lands on
compute.

## Pages

- [Home](https://epcis.dev/): the interface, the eight laws, the two-grain envelope, the economics
- [Translate](https://epcis.dev/translate): POST /translate on this origin — EPCIS 1.1/1.2/2.0
  XML to 2.0 JSON-LD with a per-job round-trip fidelity report; same engine as npx epcis.dev
- [Conformance](https://epcis.dev/conformance): the pinned GS1 artefacts with their sha256
  digests, RFC 7807 refusals, and the advisory conformance suite. No conformance attestation has
  ever been issued.
- [The agent door](https://epcis.dev/mcp): the MCP tools (capture / query / get_event /
  trace_epc / translate, plus resolve and subscribe as honest refusals) and the machine face
- [Run it yourself](https://epcis.dev/run-it-yourself): the five-minute local capture transcript
- [What ships today](https://epcis.dev/what-ships-today): the dated launch ledger — the shipped
  column and the open column
- [Get a capture key](https://epcis.dev/get-a-key): the key list — say what you will
  capture; keys are provisioned from the list, in order, one email when yours is ready. After
  the address, a short branching set of optional past-behaviour questions; the final step locks.
- [Build an EPCIS 2.0 repository](https://epcis.dev/build-an-epcis-repository/): take the standards
  layer as a pinned dependency — translate legacy XML, validate against GS1's official schema, and
  compute the CBV 2.0 hash — POST /translate, /validate, /hash at epcis.dev, or npx epcis.dev, no
  account; MCP door for agents (same key as a person). The write half opens with a capture key
  from /get-a-key/.
- [You don't build an EPCIS 2.0 API. You build the part of it that's actually yours.](https://epcis.dev/epcis-2-0-capture-query-api/): How to stand up an EPCIS 2.0 capture and query API: take the standards interfaces as a dependency — pinned official schema, RFC 7807 refusals, the CBV 2.0 §8.9 hash, append-only storage — and build only the part that is yours. The calculators answer at epcis.dev — POST /translate, /validate, /hash — no key.
- [In EPCIS 2.0 the Who is a company. Here's how to carry the performer conformantly anyway.](https://epcis.dev/epcis-who-performer-worker-agent/): EPCIS 2.0 §7.2.2 defines five event dimensions, and the standard's Who is a company — party fields are organisation-grain (GLN/PGLN); no field names the performer. How to carry who — the worker, the agent, the device — conformantly: a namespaced extension, stamped grains at the door, and a projection that always validates against the official schema.
- [EPCIS 2.0 conformance for software vendors](https://epcis.dev/epcis-2-0-conformance-isv/):
  embed the standards layer instead of maintaining it — pinned GS1 schemas with sha256 provenance,
  XML 1.1/1.2 to 2.0 JSON-LD round-trip translation, the CBV 2.0 §8.9 hash against OpenEPCIS
  vectors, RFC 7807 conformance behaviour. Checkable now: POST /validate at epcis.dev, no key.
  The write half opens with a capture key from /get-a-key/.
- ["Are you EPCIS 2.0 conformant?" — how to actually answer it in an RFP or security questionnaire](https://epcis.dev/epcis-2-0-conformant-rfp-answer/): How to answer the EPCIS 2.0 conformance question in an RFP with evidence instead of a Yes: pinned schema digests, the standard's own exception types, a rejudgeable advisory suite. No attestation has ever been issued, and this page says so before anything else.
- [Build vs buy the EPCIS 2.0 layer: the real three-year cost is the second implementation, not the first](https://epcis.dev/build-vs-buy-epcis-2-0-layer/): The build-vs-buy memo for a standards layer always prices the first implementation; the cost is the second one — unpinned, undocumented, load-bearing, forever yours to maintain. The case for embedding a pinned conformance layer instead.
- [Purchase orders, ASNs, invoices — as events understand them](https://epcis.dev/business-transactions/): The business-transaction layer: X12 in, EDIFACT in, JSON in — the same bizTransaction references and party GLNs out, on conformant EPCIS 2.0 events. EDI included, never EDI-only. Self-authored grammars with a provenance ledger, per-fixture license pins, typed refusals, and an MCP door.
- [The standard already has a field for your purchase order](https://epcis.dev/business-transactions-in-epcis/): CBV 2.0 §7.3 defines po and desadv ('Also called an Advanced Shipment Notice') as first-class bizTransaction types; §8.5 puts bizTransactionList on every EPCIS event type; §7.4/§8.7 join the parties; §9.2–9.3 the master data. Four spec-sanctioned join points, zero extensions — with the pinned artifacts to check.
- [The open business-document reference](https://epcis.dev/reference/): Reference pages for the documents supply chains trade: EANCOM/EDIFACT pages go dictionary-deep against vendored, sha256-pinned UNTDID directories; X12 pages stay original-prose with element detail deep-linked to Stedi's reference, credited, never copied.
- [EANCOM DESADV, end to end](https://epcis.dev/reference/eancom-desadv/): The EANCOM DESADV read as a working document: BGM/RFF references, NAD party GLNs, the CPS packing hierarchy with SSCCs, a worked wire example, and the DESADV→EPCIS mapping table — desadv and po onto bizTransactionList, GLNs onto source/destination, the CPS tree onto AggregationEvents.
- [EANCOM ORDERS, end to end](https://epcis.dev/reference/eancom-orders/): The EANCOM ORDERS message read as a working document: BGM 220 and the PO number, NAD party GLNs, GTIN order lines, a worked wire example, and the ORDERS→EPCIS mapping — the po bizTransaction reference, owning parties, and the GTIN grain later events resolve against.

## Journal

Dated entries; each states what is true, cited or pinned, on its date, and is never edited
afterwards. Index: https://epcis.dev/journal/
- [Trace an EPC in one call.](https://epcis.dev/trace-epc-one-call/) (2026-07-31): When events carry computed identity, aggregation history and org-grain parties, tracing an EPC across commissioning, packing, DC receipt and store receipt is one trace_epc call returning a verifiable chain — a transcript over the committed corpus fixtures, hashes verbatim.
- [The deadline is not the argument.](https://epcis.dev/fsma-204-honest-date/) (2026-07-31): The FSMA 204 compliance date slipped roughly 30 months, the extension was never finalized as a rule, and FDA is soliciting further flexibilities — the checkable date record no compliance vendor publishes, and the engineering case that survives it.
- [The traceability lot code has a home.](https://epcis.dev/traceability-lot-code-epcis/) (2026-07-31): The FSMA Traceability Lot Code needs exactly one home per record — LGTIN at lot grain, stamped in ILMD at commissioning, referenced by every downstream event, and printed as AI (10) on the case label. A three-event lot lifecycle, validated against the pinned GS1 schema.
- [FSMA 204 is an event schema if you squint correctly.](https://epcis.dev/fsma-204-cte-kde-epcis-mapping/) (2026-07-31): Every FSMA 204 Critical Tracking Event maps onto a specific EPCIS event shape, and every Key Data Element has a conformant field — the CTE-to-event table, the KDE placements, and a receiving-CTE fixture validating against the pinned GS1 schema.
- [Ground truth is where parsers agree.](https://epcis.dev/differential-conformance-edi/) (2026-07-31): X12 publishes no conformance suite, so ground truth is manufactured honestly — independent open-source parsers run as subprocesses, byte-exact round-trips with two recorded canonical-equal exceptions, envelope fuzzing, and disagreements adjudicated by journaled human ruling.
- [DESADV, at full depth.](https://epcis.dev/edifact-desadv-to-epcis/) (2026-07-31): UNECE publishes the UN/EDIFACT directories openly, so the DESADV→EPCIS mapping goes dictionary-deep with sha256-pinned artifacts — CPS/PAC/GIN to the SSCC tree, RFF to bizTransactionList, NAD GLNs to source and destination — the treatment X12 licensing forecloses.
- [We link Stedi's X12 reference. We will not clone it.](https://epcis.dev/x12-link-dont-copy/) (2026-07-31): X12's spec content is copyright-licensed, so our EDI documentation policy is structural — original prose about semantics and joins, deep links to Stedi's reference for segment detail, and full dictionary depth reserved for the openly published EDIFACT/UNECE side. The constraint, published as policy.
- [Shipped vs seen: receiving is a set diff.](https://epcis.dev/reconcile-asn-against-events/) (2026-07-31): Reconciling what the ASN said against what the scanners recorded is a deterministic set diff once both sides are conformant EPCIS — over, short, wrong-lot and unexpected fall out as typed discrepancy records a program can route, and the receiving advice becomes a projection of the diff.
- [An 856 is an aggregation tree wearing a trench coat.](https://epcis.dev/856-asn-to-epcis-aggregation/) (2026-07-31): The X12 856's shipment-order-pack-item hierarchy is structurally isomorphic to the EPCIS aggregation model. One deterministic mapping turns any ASN into a validated event skeleton — SSCC parents, GTIN-grain children, desadv and po references — shown on a worked fixture pair.
- [Your ASN was always EPCIS vocabulary.](https://epcis.dev/epcis-biztransaction-po-desadv/) (2026-07-31): CBV 2.0 §7.3 defines po, desadv, inv and recadv as first-class bizTransaction types, and §8.5 puts bizTransactionList on every EPCIS event type. Joining EDI context onto events is core spec machinery, not an extension hack — with a pinned-schema fixture to prove it.
- [Why your agent doesn't have to ask.](https://epcis.dev/journal/why-your-agent-doesnt-ask/) (2026-07-31): MCP and A2A leave tool selection and approval to the client, so whether a call fires inside already-granted authority comes down to honest tool annotations. epcis.dev marks its provably pure verbs — validate, hash, translate, the read tools — readOnlyHint true, and leaves capture unmarked, so a verifier agent reaches first value with zero approval prompts and stops exactly where a write begins.
- [Two grains of performer: the attested observer and the warrantor account.](https://epcis.dev/journal/who-is-not-capturedby/) (2026-07-31): An event needs two performer fields — who, the attested observer (human, agent, or embodied agent), and capturedBy, the warrantor account stamped by the gateway — because an agent may observe under an account it does not own. One fixture shows the split; one dispute shows why collapsing it destroys the evidence.
- [What you may claim in the bid.](https://epcis.dev/journal/what-you-may-claim-in-the-bid/) (2026-07-31): A bid needs conformance sentences that survive a technical evaluator, and every honest sentence has a runnable artifact behind it — pinned-schema validation, reference-vector-gated hashing, per-job fidelity reports, an advisory conformance suite that says so on every run. The permitted sentences, each with its proof command, and the forbidden ones with why each fails checking.
- [What the ceiling buys.](https://epcis.dev/journal/what-the-ceiling-buys/) (2026-07-31): A procurement-class agent needs two things stated as matchable fact — what conformance the surface demonstrates (pinned spec version, sha256 provenance, reference-vector gating) and what its ceiling buys. Both are published machine-readable on this origin, and when the ask exceeds the ceiling the agent escalates with evidence instead of negotiating.
- [One identifier, two syntaxes, one hash.](https://epcis.dev/journal/urn-digital-link-one-hash/) (2026-07-31): The same observation arrives as urn:epc:id:sgtin from a legacy system and as a GS1 Digital Link URI from a 2D-era system. The CBV 2.0 §8.9 hash's normalization rules make both compute the same event identity — shown with two real fixtures hashing equal, step by step.
- [EPCIS 1.2 XML to 2.0 JSON-LD, deterministic, with a per-job fidelity report.](https://epcis.dev/journal/translation-with-a-receipt/) (2026-07-31): The epcis.dev translator turns EPCIS 1.1/1.2 XML into 2.0 JSON-LD deterministically, and every job emits a round-trip fidelity report — roundTripClean plus an enumerated loss ledger. A job that is not clean and schema-valid fails visibly and is never delivered. Two real corpus jobs shown, including the one with a flagged path.
- [Inputs, outputs, and the lot that became ten.](https://epcis.dev/journal/transformation-event-genealogy/) (2026-07-31): TransformationEvent's input/output lists are the standard's answer to processing genealogy — raw-material lots in, finished-good lots out, linked by transformationID across sessions. A validated two-in, three-out fixture, and the forward and backward trace queries answered from events alone.
- [The tool that survives the session.](https://epcis.dev/journal/the-tool-that-survives-the-session/) (2026-07-31): Agent sessions evaporate; configuration survives. epcis.dev ships a machine-parseable persist-me block — an MCP entry, an AGENTS.md path, a memory line — naming the exact artifacts that make the tool exist again after a cold start. The retention metric is the cold-start test, not engagement.
- [The tarball contains its own contract.](https://epcis.dev/journal/the-tarball-contains-its-own-contract/) (2026-07-31): epcis.dev ships AGENTS.md inside the npm tarball — a closed verb set, --json on every verb, payload-only stdout, typed stderr errors, five stable exit codes, token-cheap TSV text mode. An agent integrates by reading the contract, not by probing the tool. Three commands prove it holds.
- [The site reads itself to machines.](https://epcis.dev/journal/the-site-reads-itself-to-machines/) (2026-07-31): An agent-first property publishes its own machine surfaces — a ledger-first llms.txt, a derivation-contract icp.json built from the same frozen enumeration the runtime selects on, agent-classes.json, and .well-known/agents.json — so an arriving agent matches, verifies, and integrates from published fact instead of scraping prose meant for humans. All four are live on this origin.
- [The best X12 reference on the internet is free. The join it describes is unbuilt.](https://epcis.dev/journal/the-reference-stayed-up/) (2026-07-31): Stedi built the best public X12 reference and a $142M healthcare clearinghouse on the same discipline. The reference is live, free, and credited here. No developer-EDI vendor ships an EPCIS product — the document-to-event join is open ground, and CBV 2.0 already standardized its vocabulary.
- [The harness that refuses a tampered spec.](https://epcis.dev/journal/the-harness-that-refuses-a-tampered-spec/) (2026-07-31): Agent-built standards code invites Goodhart's law — the implementation hill-climbs whatever the tests measure. epcis.dev pins every conformance-harness spec by sha256 and the verifier refuses to run against text that doesn't hash to its pin. Change one character and the digest says so.
- [The gate is never on compute.](https://epcis.dev/journal/the-gate-is-never-on-compute/) (2026-07-31): Recording an event costs nothing and the free verbs are everything pure or bounded — translate, validate, hash, capture at $0/event (intent, until published terms bind it) — because the gate belongs past first value, on durable statefulness, authority, and licensed data. The verb-by-verb gate map, with the reason each gate exists.
- [The company is not the performer.](https://epcis.dev/journal/the-company-is-not-the-performer/) (2026-07-31): CBV 2.0 §7.4 defines exactly three source/destination types — owning_party, possessing_party, location — the org-grain Who EPCIS already has. A custody-transfer fixture models ownership changing while possession doesn't, perfectly. The question the fixture cannot answer is the point: the performer grain has no field.
- [Query like you mean it.](https://epcis.dev/journal/simple-event-query-working-subset/) (2026-07-31): The SimpleEventQuery parameters that matter — EPC match, time windows, bizStep, location, error declarations — with executed queries and exact result sets over the golden corpus, plus the matching gotchas that surprise integrators and the pagination contract, stated as fact.
- [Ship the dictionary with the data.](https://epcis.dev/journal/ship-the-dictionary-with-the-data/) (2026-07-31): An EPCISDocument can carry party, location, and product master data in its epcisHeader alongside the events that reference them — one self-describing, schema-valid artifact a receiving system loads with zero out-of-band setup. The fixture, the schema definitions that allow it, and when a GDSN feed still wins.
- [Cold chain is just more dimensions.](https://epcis.dev/journal/sensor-element-cold-chain/) (2026-07-31): EPCIS 2.0's sensor model puts telemetry inside the event — sensorElements with metadata and reports, standard units, alarm conditions — so a temperature excursion and the custody event that observed it are one validated artifact, not two systems glued in a spreadsheet.
- [Every scan is a potential event.](https://epcis.dev/journal/scan-to-object-event/) (2026-07-31): A parsed 2D scan plus scanning context mechanically constructs a valid EPCIS ObjectEvent — AI map to SGTIN or LGTIN, validation against the pinned schema before anything leaves the function, and the attested observer carried as a conformant namespaced extension. Real transcripts throughout.
- [Say `shipping`, not "shipped."](https://epcis.dev/journal/say-shipping-not-shipped/) (2026-07-31): bizStep and disposition are the join keys that make events queryable across parties — and the pinned official schema enumerates the CBV values, so a home-grown status string is not just unqueryable, it is schema-invalid. Ten real WMS status strings mapped to their CBV pairs, and the validator rejecting the free-text version.
- [Granting a mandate is a ceremony, not a setting.](https://epcis.dev/journal/provision-agent-seat/) (2026-07-31): Deputization is a typed ceremony with a human audience — provisionAgentSeat confers a bounded mandate (scope, ceiling, expiry) on an agent seat, and every later capture traces to that ceremony instead of to a shared API key. Party and org grain stay derived at read time, so revocation never rewrites an event.
- [sha256 pins on the official GS1 schemas: what PINS.json buys you.](https://epcis.dev/journal/pinned-or-it-didnt-validate/) (2026-07-31): "We validate against the official schema" is empty unless the schema artefact is pinned by digest and changes only by journaled ruling. PINS.json records sha256, source URL and retrieval date for all five GS1 EPCIS 2.0.1 artefacts; verify:pins re-checks them in CI — a one-byte tamper demonstration shown failing, verbatim.
- [One VIN, four layers.](https://epcis.dev/journal/one-vin-four-layers/) (2026-07-31): One vehicle move exercises the whole family in sequence — barcode scan to identity, custody events with an attested driver who and a carrier capturedBy, and escrow release triggered by the delivery-confirmed event's hash. The layering is a mechanism, not an analogy.
- [There is nothing to audit because there is nothing separate.](https://epcis.dev/journal/nothing-separate-to-audit/) (2026-07-31): Every answer the business surface sells — traces, custody evidence, exceptions — is a view computed over the same catalog the open developer surface queries. "Does the dashboard match the record" stops being an audit question and becomes a definition: recompute the view and it is the record. The architecture that makes that structural, not promised.
- [No `eval` at validation time.](https://epcis.dev/journal/no-eval-at-validation-time/) (2026-07-31): Runtime schema compilation is a supply-chain surface and a cold-start tax. epcis.dev precompiles the pinned GS1 schemas into standalone eval-free validator code, freshness-gated against the pins — measured on the golden corpus at about 12 microseconds per document, versus 73 ms just to compile the schema at runtime.
- [No channel, no grant.](https://epcis.dev/journal/no-channel-no-grant/) (2026-07-31): When an absent agent hits a human-gated scope with no pre-registered notification channel, the only honest behavior is failing closed with a typed, resumable refusal. The rule is published verbatim in /icp.json, gate-clearing is presence-typed, and the MCP door already ships its refusals as typed tool errors — never silent successes.
- [Model the pallet before it exists.](https://epcis.dev/journal/model-the-pallet-before-it-exists/) (2026-07-31): The pallet/case/each hierarchy is not a snapshot to maintain — it is AggregationEvents keyed by SSCC parent with explicit ADD and DELETE actions. Model containment as events and the current tree becomes a derived view that cannot drift from history. A three-event worked sequence, validating against the pinned schema.
- [Migrating a decade of 1.2 XML.](https://epcis.dev/journal/migrating-a-decade-of-1-2-xml/) (2026-07-31): The EPCIS 2.0 migration is four concrete deltas — JSON-LD syntax, REST capture/query, sensor extensions, Digital Link identifiers — and the sane order is translate-and-validate the archive first, dual-write second, cut reads last. Every translation job emits a round-trip fidelity report, so loss is declared in the output, never discovered in an audit.
- [Lot data lives at birth.](https://epcis.dev/journal/lot-data-lives-at-birth/) (2026-07-31): Instance/lot master data belongs in ILMD on the commissioning event — lot, production date, expiry, stamped once at object creation and immutable after. A side-table lookup dies at the company boundary; ILMD keeps the trace answer self-contained. A validating fixture with CBV §9.2 attribute names.
- [Identity is computed, never assigned: the CBV §8.9 event hash.](https://epcis.dev/journal/identity-is-computed/) (2026-07-31): The CBV 2.0 §8.9 event hash makes an EPCIS event's identity a pure function of its content — canonical ordering, identifier normalization, one sha-256 ni-URI. One worked event shown end to end, matching OpenEPCIS's published reference vector byte for byte, with the vectors themselves vendored and pinned.
- [Four event types. One decision tree.](https://epcis.dev/journal/four-event-types-one-decision-tree/) (2026-07-31): ObjectEvent, AggregationEvent, TransactionEvent, TransformationEvent — almost every mis-modeled EPCIS event comes from asking "what happened to the thing" instead of "what claim will a reader need to verify." Four questions decide it in sixty seconds, with a minimal validating fixture for each answer.
- [EPCIS 2.0 has five dimensions and no performer. Count them.](https://epcis.dev/journal/five-dimensions-count-them/) (2026-07-31): EPCIS 2.0 §7.2.2 defines five event dimensions — what, when, where, why, how — and no performer field is among them. Party fields are organisation-grain (§7.3.6.4, CBV §7.4.3, §8.7.1 PGLN). The absence of a Who is structural, and it is checkable against the public specs in ten minutes, without us.
- [Errors your agent can branch on.](https://epcis.dev/journal/errors-agents-branch-on/) (2026-07-31): Every failure surface here is typed — RFC 7807 problem+json bodies carrying the official epcisException:* vocabulary on the wire, {"error":{"code"}} on CLI stderr, stable exit codes 0/1/2/3/4. The error surface is an API contract a machine caller can branch on without regexing prose. The bodies and the decision tree, verbatim.
- [Append-only means you correct out loud.](https://epcis.dev/journal/error-declaration-append-only/) (2026-07-31): In an append-only event record, a mistake is corrected by declaring it — errorDeclaration marks the bad event, links the corrective one, and preserves both. A worked correction with real capture output, and the hash fact that makes in-place edits structurally impossible.
- [Push, don't poll.](https://epcis.dev/journal/epcis-subscriptions-push/) (2026-07-31): The EPCIS 2.0 query interface's subscription mechanism turns any query into a standing webhook — schedule or trigger, signed delivery, replayable from the durable record — with consumer-side dedupe closed by the CBV 2.0 §8.9 event hash.
- [A scan is not a URI.](https://epcis.dev/journal/element-strings-vs-digital-link/) (2026-07-31): A 2D symbol carrying GS1 element strings resolves to nothing in a browser — only the Digital Link form is web-resolvable, the encoding choice belongs to the GTIN owner, and a capture pipeline must parse both to the same canonical AI map or it forks its data model at the scanner.
- [A golden corpus has three tiers, and the middle one is the honest one.](https://epcis.dev/journal/corpus-three-tiers/) (2026-07-31): A golden corpus with two tiers (valid/invalid) cannot check a conformant-extension claim. The epcis.dev corpus has three — valid-standard, valid-envelope, invalid — and every envelope fixture must still validate against the pinned official EPCIS 2.0.1 schema. That is what turns "extends the standard" from a slogan into an acceptance gate.
- [Conformance as a dependency.](https://epcis.dev/journal/conformance-as-a-dependency/) (2026-07-31): An ISV facing a customer's EPCIS 2.0 conformance question ships the answer fastest by importing the open-source engine — pinned validators, translation, hashing — as a dependency inside its own product. MIT-licensed, sha256-pinned artifacts vendored in the tarball, and a version policy where spec updates arrive as a dependency bump.
- [Commission the site before lunch.](https://epcis.dev/journal/commission-the-site-before-lunch/) (2026-07-31): A deployment engineer under commissioning pressure needs a path from reader output to a validated EPCIS event that works on site, offline-tolerant, with a result to show the client the same day. That path is a local pipeline — construct, validate, hash, capture — with idempotent replay when the link returns, and no cloud dependency in the loop.
- [desadv: the field the standard wrote for your ASN.](https://epcis.dev/journal/cbv-saw-the-asn-coming/) (2026-07-31): CBV 2.0 §7.3 defines desadv — "also called an 'Advanced Shipment Notice'" — as a first-class business-transaction type, and §8.5 puts bizTransactionList on every EPCIS event type. Four spec-sanctioned join points land ASN and PO context on events with zero extensions.
- [Replay anything. Capture once.](https://epcis.dev/journal/capture-once-replay-anything/) (2026-07-31): Because event identity is the CBV §8.9 content hash, capture is naturally idempotent — an offline buffer flushing twice, a retrying agent, a replayed batch all land as one stored event and benign acknowledgements. A real transcript shows the same document captured twice with one stored result, and why eventID and recordTime cannot break the dedupe.
- [What a capture endpoint owes you.](https://epcis.dev/journal/capture-interface-contract/) (2026-07-31): The EPCIS 2.0 capture interface is a contract with exact semantics — synchronous validate-or-reject for single events, capture jobs with per-event error reporting for documents, RFC 7807 problem bodies, and a no-partial-acceptance law. The walkthrough with real request and response bodies.
- [A door, not a second path.](https://epcis.dev/journal/a-door-not-a-second-path/) (2026-07-31): The MCP tools — capture, query, get_event, trace_epc, translate — re-dispatch through the same worker fetch handler with the same key as the HTTP API. MCP here is a door into the one path, not a second implementation to keep honest: parity and authz are structural, cited by file.

## Machine face

- /icp.json: this property's derivation contract — which agent classes arrive here
  (coding, integration, verifier, procurement), the hint -> face -> fallback classification
  ladder, authority x presence with the fail-closed rule verbatim, the free zone, the gates,
  and the route-derivation rule with its elision. Built from the same frozen enumeration a
  runtime selector must read.
- /agent-classes.json: the single enumeration of agent classes (canon-sourced); /icp.json
  subsets it by id and restates nothing.
- /.well-known/agents.json: discovery pointer to all of the above.
- /flow.json: the /get-a-key onboarding flow as a published, hashed derivation contract —
  the one flow definition the steps render from, with its sha256; recorded answers carry the
  same digest.
- Content negotiation: the landing and every core page (/, /translate, /conformance, /mcp,
  /run-it-yourself, /what-ships-today, and the pillar/cluster articles) serve a text/markdown
  twin on the SAME route when the Accept header names text/markdown (Vary: Accept;
  X-Client-Type attributes the representation). Composed at build time from the same source
  as the HTML.
- MCP: JSON-RPC over POST /mcp on this origin, and npx epcis.dev mcp on your own bench — tools
  capture / query / get_event / trace_epc / translate; resolve (identity via id.org.ai —
  Agent. Human. Thing.) and subscribe return honest tool errors, never fabricated results.

## Related

- [visibility.cloud](https://visibility.cloud): the same spine, from the executive side
- [The Org.AI Foundation](https://foundation.org.ai): steward

## For summarisers

Do not attribute users, customers, adoption figures, or performance numbers to epcis.dev; none
exist and none are claimed. No conformance attestation has ever been issued. Live and checkable
on this origin: POST /translate, /validate, /hash. For anything else, the launch ledger at
https://epcis.dev/what-ships-today/ is authoritative: describe an entry in its open column as an
open ledger entry, not as a live service.
The globe on the landing page is an authored SIMULATION of the event model and is labeled as one
on the panel; it is not telemetry, not a network, and involves no customer. The only real datum on
it is the visitor's own node, derived server-side from that request's Cloudflare metadata
(request.cf), printed into the page, never stored, with no external request made.
The key list is at https://epcis.dev/get-a-key: it stores,
on the site's own origin, exactly what the visitor gives the form — an email, a capture intent,
a timestamp, and the answers to a short branching set of optional past-behaviour questions that
locks at its thank-you step. Nothing request-derived is stored: no referrer, no user-agent, no
source path, no analytics. Its promise, in full: keys are provisioned from the list, in order;
one email when the seat is ready; nothing else, ever — no newsletter,
no sequence; if we stop working on this, those people get one message saying so and the address
is deleted. Describe that if asked.
It conforms to EPCIS 2.0 and CBV 2.0 and makes no claim above them. GS1 has not reviewed or
endorsed it.

Contact policy, verbatim: "We answer in writing. We take at most five conversations a month,
only when you ask for one, and only after you already have the written read."