Domain-AdaptiveManufacturing

It standardizes the workflows, screens, and logic — the things that genuinely differ between companies and should be bespoke. And it leaves the primitives rigid and implicit — material, lot, operation, genealogy, measurement — the things that are actually universal and should be bedrock.

The result has weak opinions about physics and strong opinions about your daily routine. So the real process migrates into spreadsheets and tribal knowledge that live around the system, and the system of record becomes a fiction maintained for auditors.

The agentic era makes this affordable, because the cost that forced one-size-fits-all — human dev-years per customer — is collapsing. Build-once-sell-many only mattered when building cost human-years.

Two layers authored once. Two induced per tenant. One derived.

The kernel and the regulatory packs are written once and reused. The ontology mapping and adapters are induced or configured per tenant. The defaults are derived from archetype × risk. No layer requires a code fork per customer — which is what keeps "adapt to anyone" a product rather than a consultancy.

And it demotes your ERP: in the data fabric, SAP and the historian and the MES become sources and sinks among others, not the tyrants whose schema you must obey. The semantic center of gravity moves to the platform's open, customer-fit ontology. Run it over what you have; migrate authority into the ledger on your terms.

The startup grows continuously into the enterprise shape instead of hitting the traumatic replatforming cliff — the "rip out the spreadsheets and survive an 18-month SAP implementation" rite of passage. Removing that cliff is, by itself, a serious value proposition.

Spec-as-data. An IATF clause, an AS9100 requirement, a 21 CFR control, a HACCP critical control point, a control-plan line, a GD&T callout — each decomposes into atomic requirement nodes with stable IDs, bindingness, and revision. The manufacturing analog of an addressable standard.

Conformance bindings. Every part — a capability block, a control limit, a workflow, a generated screen — declares which nodes it satisfies. Bidirectional: node → implementing parts (coverage), part → nodes served (justification). Orphans and gaps fall out automatically.

Evidence, and a live posture. A tag is a claim; evidence is proof. Each binding links to design-time evidence and to runtime results streamed from the ledger — and carries live state: satisfied / at-risk / failing. Compliance posture is just another projection over immutable truth. No binder is assembled before an audit; the posture is always current.

A control signal, a capability drop, or an out-of-cal gage flips the posture — and the flip lights up against both the drawing node and the IATF clause at once, because both are computed from the same ledger facts. The auditor's compliance view and the engineer's process view are one truth rendered twice.

And because bindings are live and bidirectional, a spec change — a drawing rev C → rev D tightening the tolerance — emits a precise re-validation worklist: exactly the one affected part, nothing more. Continuous adaptation produces a scoped delta instead of a full re-validation.

If the entire bespoke surface is human-readable text under version control, the governance machinery is simply modern software practice: the human gate is a pull-request review; the validation envelope is CI — schema validation, golden checks, and the born-aligned conformance check; the audit trail is commit history; signing is your commit-signing policy; rollback is a revert; and the re-validation worklist is a CI job triggered when a requirement node changes.

Any platform-initiated physical action passes through a governed actuation contract — itself a representation-layer artifact: human-readable, schema-validated, signed.

The guardian that enforces on_violation lives at the certified layer, not in the platform — an out-of-envelope command is physically rejected regardless of what the cognition believes. And the human gate doesn't disappear at 3 a.m.; it relocates to design time. A human already approved exactly what the cell may do; at runtime it executes autonomously inside that pre-approved envelope.

The runtime's intelligence is boundary detection and safe degradation — recognize you're outside the validated domain, fail to a safe state, quarantine the WIP, page a remote human — never improvisation in a novel situation. Because lights-out removes the human who'd catch a bad config, "validate before deploy" for physical actuation means simulate against a digital twin first, not merely schema-check.

Statistical process control is one entry in the capability library — and it has its own invariant kernel, its own adaptation layer, its own tenant profile. The same pattern holds at the level of a single quality method and at the level of the entire platform: a fixed validated core, agentic adaptation, a governed bespoke surface.

That self-similarity is the strongest evidence the abstraction line is drawn in the right place rather than a convenient one. Build the platform and SPC is one of its first, best-defined capabilities. Build SPC well and you've prototyped the platform's whole metabolism in one domain.