The Shop Floor and the Digital Twin: Where Ontologies Are Still Arriving

📍 Where we are: Part VIII · Ontologies in Industry Today. The previous chapters found the laboratory and the regulatory boundary semantically mature. Now we walk onto the production floor, where the model this book built meets the place it has reached last.

The lab has Allotrope and SiLA; the regulatory boundary has IDMP and structured submissions. Both are places where formal semantics already do real work. The GMP (Good Manufacturing Practice) production floor — the bioreactors, the chromatography skids (the pre-plumbed, frame-mounted purification units), the manufacturing execution system stitching them together — is different. It is the most instrumented part of the plant and the least ontologized. The data is enormous and the stakes are highest, yet the working "semantics" of the floor today are not ontologies at all.

This chapter is honest about that frontier. Two kinds of model genuinely run in production there, and neither is a formal ontology: structured information models that move shop-floor data between systems, and statistical models that decide whether a batch looks like the good ones. The formal-ontology layer — the kind this book has spent its modeling chapters building — is arriving, but it arrives as proofs of concept, consortium pilots, and academic releases. Telling those two worlds apart is the whole point of the chapter.

The simple version

Picture a busy kitchen that runs flawlessly. Orders move on printed tickets in a fixed format every station understands, and the head chef judges each dish against a photo of the perfect plate. It works — but nobody has written down what a "dish" actually is, how it relates to its ingredients, or why this sauce counts as the same recipe as last week's. The tickets and the reference photo are not a cookbook you can reason over. The floor of a biologics plant is that kitchen: it has tickets and reference photos in abundance, and it is only now starting to write the cookbook.

What this chapter covers

We separate three things that are easy to blur. First, structured information models — the ISA-95/IEC 62264 hierarchy and its B2MML XML serialization, the manufacturing execution system (MES) master batch record, and the asset-framework contextualization layer — which run in production but are not formal OWL ontologies (the Web Ontology Language, the formal modeling language this book builds in — see Classes and Taxonomy). Second, statistical models — the multivariate Continued Process Verification (CPV) approach built on a "golden batch," which is mathematics, not semantics. Third, the genuinely ontological work: the interoperability pilots (Asset Administration Shell, SiLA 2, OPC UA LADS, SOSA/SSN), the bioprocess ontologies themselves (BioPhorum, MCBO, the IOF Biopharma reference ontologies), and the digital twins that some hope will eventually stand on them. Throughout, every adoption claim carries a maturity tag, because on this floor the gap between shipped and proposed is the most important fact there is.

The GMP shop floor sorted by maturity: structured and statistical models run in production today, while formal bioprocess ontologies and ontology-grounded digital twins are still pilots and academic work. Original diagram by the authors, created with AI assistance.

What actually runs: structured and statistical models

Start with what is unambiguously in production — and notice that none of it is an ontology in this book's sense.

The connective tissue of the floor is ISA-95 (the ISA-95/IEC 62264 standard for enterprise-control integration) and its XML serialization, B2MML (Business To Manufacturing Markup Language). Together they define the vocabulary and message shapes by which an ERP system and an MES exchange information across ISA-95's functional levels — Level 4 (the ERP / business-planning layer) and Level 3 (the MES / manufacturing-operations layer) — what to make, in what quantity, against which order. The major MES platforms a biologics plant might run — Körber PAS-X, Siemens Opcenter, Rockwell FactoryTalk PharmaSuite, AVEVA, Dassault Apriso, SAP Digital Manufacturing — all build on this layer. The documented Genentech case integrated SAP IDocs to B2MML, and the pattern became common enough that SAP later shipped B2MML content packages [1]. This is a semantic information model in production — but it is a structured XML schema, not a formal OWL ontology you can run a reasoner over (a reasoner is software that derives new facts and checks consistency from the stated axioms — the capability that distinguishes a formal ontology from a schema that merely moves data). (production)

Alongside it sits the MES master batch record (MBR) — the electronic recipe and the as-executed batch record it generates. This is where our running example's bp:BATCH-2026-001 actually lives on a real floor: not as an RDF node with a derivedFrom edge to bp:SEED-001 (RDF models data as a graph of subject–predicate–object triples, where a node is a thing and an edge is a named relationship between two things — see Instances and the Graph), but as a row in a proprietary MES database, the genealogy encoded in the vendor's own model. The same is true all the way out to the released bp:DS-001 and bp:DP-001 lots: the relationships are real, and what is missing is not the ability to lift them out — it is the governed, plant-wide adoption that would make every system lift them out the same way.

That distinction matters, because this book already showed the crosswalk can be walked. OPC UA is the open machine-to-machine protocol that carries a bioreactor's live probe values on the wire, read straight off the controller — the "wire" the from-the-wire-to-the-graph crosswalk picks data off of. The companion loaders b2mml_to_rdf.py and opcua_to_rdf.py read a real-shaped B2MML batch-production record and a handful of OPC UA variable reads, and emit precisely the bp: triples this book models: the batch typed once as bp:BATCH-2026-001 a bp:Batch, the run occursIn bp:BR-101, each probe read as a sosa:Observation carrying its UCUM unit, all indexed back to the batch (the full demonstration is From the Wire to the Graph). The mapping is a few hundred lines. So the formalism is portable in principle; what the floor lacks is not the mapping but a shared identifier scheme that every MES, data historian (the time-series system that archives dense probe streams), and twin agrees to mint against. The non-portability is a fact about adoption, not about feasibility.

And the portability is checkable, not just asserted, because the companion stack is open source and runs on a laptop. The triples those loaders emit are gated by the book's executable ORSD (Ontology Requirements Specification Document): the 23 competency questions in cq-catalog.json run as per-CQ PASS/FAIL acceptance tests by validate.py, so "does the lifted graph answer what the floor needs?" is a mechanical check, not an opinion — the same requirements == tests discipline the specification chapter built, and the same open RDFLib/SPARQL/SHACL tooling the companion knowledge-graph chapter deploys behind a Fuseki triplestore. A floor whose lifted graph passes that suite has demonstrated portability against tests; the gap the floor still has is governance, not green checkmarks on a laptop.

The second production-grade model is statistical. Continued Process Verification — the FDA's Stage 3 of process validation, the ongoing assurance that a process stays in its validated state — is implemented today as multivariate statistics over a golden batch (a reference profile distilled from historically good runs). The deployed mathematics is principal component analysis and partial least squares (PCA/PLS) — methods that compress dozens of correlated process variables into a handful of summary components (the batch's scores), defining a low-dimensional space in which a normal batch occupies a tight cloud — with Hotelling's T-squared and Q-residual statistics flagging when a live batch drifts off that manifold of normal operation. It is packaged in commercial tooling — MilliporeSigma's Bio4C ProcessPad, Sartorius/Umetrics SIMCA — and an ISPE case applied it to a 5,000-L stainless-steel cell-culture batch (larger than this book's 2,000-L single-use mAb-A reactor, but the multivariate method is scale-independent) [11]. It answers "is this batch like the good ones?" with real rigor. But it is a statistical data model, not an ontology: it computes distances; it does not represent meaning. (production)

Concretely, the golden batch for the mAb-A campaign is a multivariate envelope built over the critical process parameters the bioreactor actually held — culture temperature at 36.5 °C inside a normal operating range of 36.0–37.0 °C, the relative feed rate at 0.40 vessel-volumes per day (NOR 0.35–0.45), with dissolved oxygen, pH, viable-cell density and viability riding alongside — and it is scored against the critical quality attributes the lot is released on: SEC %monomer (98.611% against a 95.0% floor), CEX %main charge variant, host-cell protein (the released bp:DS-001 at 12.0 ppm against a 100 ppm limit, well below the 850 ppm seen in-process right after capture, where the Protein A affinity step does most of its clearance), residual DNA, and potency. Hotelling's T-squared asks whether the run's PCA scores sit inside the cloud of historically good batches; the Q-residual asks whether anything happened that the model has never seen at all. That is real Stage-3 rigor over exactly the QbD (Quality by Design — the framework under which critical process parameters and critical quality attributes are defined) vocabulary the release gate and the axioms built — but it is a statistical distance in score space, not a node a reasoner can traverse. The downstream unit operations carry their own golden-batch envelopes the same way: the capture-pool host-cell-protein and yield, the viral-inactivation hold time and pH, the polishing column's pooling cut points, and the UF/DF final concentration and buffer-exchange endpoint are each a CPP-and-CQA bundle scored against its own historical cloud — and in the graph each is one bp:Quality trace hung off its own bp: process node, never collapsed into the upstream run. (production)

A quality reviewer reads two things this structured-vs-statistical split bears on directly. The first is data integrity: a golden-batch model and an MES batch record are only as trustworthy as the ALCOA+ controls under them (Attributable, Legible, Contemporaneous, Original, Accurate, plus Complete, Consistent, Enduring, Available — the data-integrity principles that make a record stand in for the medicine), and the legal force behind those controls is 21 CFR Part 11 and EU GMP Annex 11, which make the electronic batch record and its audit trail count as much as signed paper (see Part 11 / Annex 11). A formal ontology does not replace that machinery — but it makes the audit trail queryable: where a proprietary MES holds the who-did-what-when in a vendor schema, a bp: graph can carry the same attribution as typed triples a SPARQL query can traverse, which is exactly why a governed graph turns recall traceability from a manual reconstruction into a reasoned walk. The second is validation effort: under the FDA's shift from CSV (Computerized System Validation) to CSA (Computer Software Assurance — risk-based critical thinking over rote scripting; see CSV to CSA), the depth of testing scales to how much a system influences a release decision. A golden-batch CPV model that flags a batch for review and a future ontology-grounded twin that informs a CQA both sit high on that risk scale — which is one more reason the formal layer arrives slowly: it is not enough to model the floor, the model must be qualified to the same IQ/OQ/PQ standard the chromatography skid it describes already passes.

Layer	What it is	Formal ontology?	Maturity
ISA-95 / B2MML	XML information model for ERP↔MES exchange	No (structured XML)	(production)
MES master batch record	Proprietary electronic recipe + genealogy	No (vendor model)	(production)
CPV / golden batch	Multivariate statistics (PCA/PLS)	No (statistical)	(production)
Interop metamodels (AAS, SiLA 2, OPC UA LADS)	Interoperability / twin metamodels	Partly / mappable	(piloted)
AAS (IEC 63278) — worked example	Digital-twin container; nameplate + technical-data submodels	Partly (mappable; modeled here as bp:AssetAdministrationShell)	(piloted; worked example in this book)
SOSA/SSN	Sensor telemetry ontology	Yes (W3C/OGC)	(production standard)
MCBO, NIST DT, IOF Biopharma	Formal bioprocess ontologies	Yes (BFO/IOF)	(academic / proposed)

The interoperability pilots: metamodels reaching for the floor

One layer above the production floor, a set of standards is being piloted that would make floor data portable enough for ontologies to grab onto.

The Asset Administration Shell (AAS) is the Industrie 4.0 digital-twin metamodel defined by IEC 63278 — a standardized container describing an asset's identity and submodels (nameplate, technical data), mappable to OPC UA. ISPE's Pharma 4.0 Plug & Produce subcommittee published a proof of concept integrating qualified lab devices with the AAS as a digital twin (2023) — concept-paper stage, not a production deployment [2]. (piloted)

It is worth saying where this book stands in that landscape, because it built the toy version of exactly this. The companion ontology already carries an Asset Administration Shell: the class bp:AssetAdministrationShell (its definition citing IEC 63278) and the individual bp:AAS-BR-101, whose bp:describesAsset edge points at the physical vessel bp:BR-101, with the nameplate and technical-data submodels modeled as the datatype properties bp:equipmentManufacturer, bp:assetSerialNumber, and bp:maxWorkingVolumeL.

bp:AAS-BR-101  a  bp:AssetAdministrationShell ;
    rdfs:label         "AAS of production bioreactor BR-101" ;
    bp:describesAsset  bp:BR-101 ;          # the shell IS the twin of the real vessel
    bp:maxWorkingVolumeL  "2000.0"^^xsd:float .   # technical-data submodel (2,000-L single-use reactor)

The design move is the one the pilots are reaching for: because bp:describesAsset resolves the shell to the same bp:BR-101 individual that the genealogy, the ISA-95 equipment hierarchy (bp:isEquipmentPartOf, up through process cell, area, site, enterprise), and the occursIn edges already use, the twin's equipment node and the ontology's equipment node are not two records to reconcile — they are one IRI. That identity is cheap to assert in a worked example and expensive to retrofit across a plant of vendor shells, which is precisely why AAS is still piloted on the real floor. (piloted; worked example in this book)

SiLA 2 (Standardization in Lab Automation, version 2) is an open, royalty-free standard for lab-device connectivity, paired with AnIML for analytical data. It is in early, piloted deployment: an open-source SiLA 2 connector for Tecan's FluentControl was released in 2024 with support from Tecan, UniteLabs, and Roche, and Roche's "AC/DC" concept uses SiLA 2 drivers in its Basel R&D setting [3]. A further claim that this connector passed Site Acceptance Testing and expanded across Roche was not found in public evidence, so we leave it aside. (piloted)

OPC UA LADS (OPC 30500, the Laboratory and Analytical Device Standard) — the first OPC UA companion specification for lab and analytical devices, released around December 2023 — was demonstrated end-to-end at a 2025 hackathon alongside the Allotrope Foundation Ontology and ASM, uniting the communication standard (live data on the wire) with the data standard (documented, structured results). The published artifacts are explicitly proof-of-concept simulators, not shipped products [4]. (piloted)

Finally, SOSA/SSN — the W3C/OGC Semantic Sensor Network ontology — is the standard, vendor-neutral way to model sensor, PAT, and bioreactor telemetry semantically [5]. It is the formal-ontology counterpart to the proprietary contextualization an asset framework such as AVEVA PI Asset Framework provides — and it is the formalism this book already uses for floor telemetry: the from-the-wire-to-the-graph loaders map each PI historian row and each OPC UA variable read into one sosa:Observation (sosa:observedProperty, sosa:hasSimpleResult, sosa:resultTime), carrying the UCUM code (Unified Code for Units of Measure) and, where one exists, a QUDT unit IRI (an identifier from the QUDT units ontology), while the dense stream stays in the historian behind a single bp:hasTrace index edge per batch and tag. A probe reading, in other words, is modeled as a sosa:Observation and indexed in the static graph as a bp:Quality trace — never as the bioreactor process itself, which is the separate bp:CCP-001 cell-culture run. SOSA/SSN is a mature, production-grade standard; uptake on the pharma floor specifically remains light. (production as a standard; light pharma-floor uptake)

Adjacent to the AAS, the Module Type Package (MTP) — the VDI/VDE/NAMUR specification standardized as IEC 63280 — is a structured plug-and-produce description of a process module, riding on OPC UA, that lets a single-use skid be orchestrated by a process-control system without bespoke integration. It is directly relevant to the modular single-use floor a mAb plant runs on, and it reaches toward portability — but like B2MML it is a structured description format, not a formal ontology of what a module's service means; the standards-and-consortia chapter places it in the wider landscape. (piloted)

The bioprocess ontologies themselves

Now the formal ontologies — the ones that would actually represent the floor's meaning. They exist, they are good work, and not one of them has a named production deployment in biomanufacturing.

The BioPhorum biomanufacturing ontology ("Big Data to Smart Data," November 2023) is a system-independent ontology for biomanufacturing process data. It was validated at NC State's BTEC, where it reportedly cut an OD-probe calibration workflow across five bioreactors from four hours to thirty minutes [6]. That figure is a single consortium proof-of-concept datapoint — read it as one validation case, not a representative metric. (piloted)

Two academic ontologies apply this book's own foundations directly. NIST's "Towards Ontologizing a Digital Twin Framework for Manufacturing" (2023) uses BFO (the Basic Formal Ontology, the upper ontology this book builds on — see The Upper Spine) and IOF Core (the Industrial Ontology Foundry's mid-level vocabulary) to formalize the ISO 23247 digital-twin framework, with a bioreactor as its worked biomanufacturing example [8]. And MCBO (the Mammalian Cell Bioprocessing Ontology) is a BFO + IOF Core hub-and-spoke ontology posted to bioRxiv in early 2026 — not yet peer-reviewed — validated on 723 curated cell-culture instances against SPARQL competency questions (test queries the ontology must answer correctly — the book's validate.py / ORSD) and MIT-licensed for behind-firewall use, with no named industrial deployment [9]. These are exactly the kind of model our bp: graph is a small cousin of: BFO-grounded, IOF-aligned, queryable. (academic)

The closest thing to a coordinated reference effort is the OAGi/NIIMBL IOF Biopharma ontologies — BFO- and IOF-Core-aligned reference ontologies drawing on ISA-88 and ISA-95. A public release appeared in December 2024, with a larger formal release announced for late 2025 [10]. A claim that the Pistoia Alliance's CMC Process Ontology imports these is not corroborated by Pistoia's own release, which cites only ISA-88/95 — so we do not assert the link. (proposed)

The digital twins on top

The digital twins that capture headlines are real and impressive — and they are built on hybrid mechanistic and machine-learning models, not on formal ontologies. Samsung Biologics' tri-modal bioreactor twin combines computational fluid dynamics, first-principles kinetics, and multivariate/ML modeling; GSK's closed-loop vaccine twin (built with Siemens and Atos from 2019) closes a control loop around a single process [7]. Both are scoped to a single unit operation, and the "closed-loop" characterization of the GSK case rests on 2019-era vendor PR, so read it as a vendor claim. The math is mature; the semantics underneath — the part that would let one twin's model mean the same thing as another's — is the missing layer. (piloted)

The companion ML book builds exactly this kind of twin — a parallel grey-box titer model where a mechanistic backbone (titer as the specific productivity qP times the integral of viable cell density) carries the trend and a small neural network learns only the residual the physics misses, over this same BATCH-2026-001 (the hybrid-models chapter walks the runnable code). That cross-reference sharpens what the graph is for in the ML stack: the twin is a statistical object, but its training data, its inputs, and its drift signals are nodes the ontology can type and govern. Three connections are worth naming, because they are where ontology stops being decorative and starts constraining a model.

First, the ontology is the ground truth a model is graded against — not the other way round. A learned twin can return a fluent, plausible titer that is quietly wrong; the reasoned graph cannot, because its bp:derivedFrom lineage and its SHACL release shapes either hold or fail loudly. That asymmetry is the validation paradox the release gate and the next chapter turn on: a model is plausible, a reasoned graph is checkable, so the graph is what certifies the model's training subgraph is complete and well-typed — every batch with its bp:derivedFrom parent, every CQA with its value and UCUM unit — before a model is allowed to learn from it. Hand a model a hollow or mislabeled graph and it will not fail quietly; it will narrate the gap with confidence. SHACL refusing a non-conformant retrieval is the same gate that refuses a non-conformant release.

Second, learning over instances inherits the individuation problem this chapter is about. A twin generalizes only if its held-out test reflects a genuinely new run, which means splitting by batch — grouped, leave-one-batch-out cross-validation — rather than splitting timepoints of one run into train and test, which leaks one batch's state into its own evaluation (the models-and-validation chapter makes the split-by-batch discipline a requirement). The grouping key is precisely the bp:Batch individual whose identity this chapter spent its bona-fide-versus-fiat analysis defending: in a discrete line the batch is the natural fold; in a continuous line, where the "lot" is a fiat object carved by a time interval, even the cross-validation fold becomes a modeling decision. The same boundary problem that stalls a continuous-line ontology also blurs what "a held-out run" even means for the model.

Third, the ontology supplies an applicability domain — a check that a new batch resembles the runs a model was trained on, so the model can decline to guess out of its depth. The lineage edges tell you when a batch sits outside the trained envelope (a new working-cell-bank vial, an un-seen scale) before any prediction is trusted, and the unit-bearing sosa:Observation telemetry is what makes "out of envelope" a graph query rather than a guess. A retrieval-augmented LLM asked about the floor faces the mirror image: ungrounded, it composes a confident invented answer; grounded against the bp: graph and made to abstain when the graph does not support a claim, it narrates a true lineage instead — the GraphRAG argument the frontier chapter develops in full. In every case the formal ontology is doing the one thing a statistical twin cannot: telling the model when it is outside what it knows.

The unsolved part: the floor's meaning still lives in proprietary and statistical models

The honest summary is uncomfortable. On the GMP shop floor, the working semantics are structured (B2MML, the MES batch record, the asset framework) and statistical (the golden-batch CPV model). The formal-ontology layer is a frontier of proofs of concept and academic ontologies with no named production home. Two specific gaps echo verdicts this book reached earlier. First, continuous-processing individuation: when product flows continuously rather than in discrete lots, the clean batch and unit-operation boundaries our bp:BATCH-2026-001 relied on dissolve, and no settled ontology yet exists for time-bounded lots in a continuous line. Stated in this book's own terms, the problem is one of bona-fide versus fiat boundaries. A discrete batch is a material entity with a natural boundary — the vessel is charged, runs, and is harvested — so bp:BATCH-2026-001 individuates cleanly and bp:derivedFrom, a transitive relation over discrete materials, has well-defined endpoints to connect. In a continuous line the product is a flowing stream with no such boundary, so a "lot" becomes a fiat object carved out by a chosen time interval, and the individuation criterion is a modeling decision, not a fact the process hands you. No published ontology has settled that criterion for continuous biomanufacturing, which is why this gap is genuinely open and not merely unbuilt. Second, the data-standardization bottleneck — across the digital-twin literature, FAIR (Findable, Accessible, Interoperable, Reusable) and semantic data standardization, not the modeling and not the math, is repeatedly named as the chief obstacle to scaling twins and manufacturing AI. That "modeling is solved, the data is not" framing leans heavily on a single review; treat it as a defensible opinion, not an established fact.

Why it matters

This is where the book's model meets its hardest reality. Our bp: graph treated a unit operation as a clean process node with a derivedFrom edge and a CQA attached. The real floor still encodes that same relationship in a proprietary master batch record or a statistical golden-batch model — both of which work, and neither of which is a governed, validated ontology you can reason over or share. And the proprietary model is not merely unportable, it is non-reconcilable: two MES vendors mint two different identifiers for the same physical lot — the very individuation problem this book has fought since Instances and the Graph. Without a shared scheme to say these two names denote one batch, the genealogy that makes a recall traceable stops at the plant fence. A governed ontology is what turns two vendors' rows into one reasoned-over individual. Turning the floor's meaning into a formal model is unfinished, and the reason is not a shortage of cleverness. It is a shortage of discipline: shared identifiers, FAIR data, validated vocabularies. That is precisely why the closing chapters of this book are about discipline, not technology.

In the real world

What is actually shipping on the floor — versus what is piloted — sorts cleanly, and the evidence is worth gathering in one place rather than leaving scattered through the survey. In production: the ISA-95/B2MML information model moves work between ERP and MES, concrete enough that the Genentech SAP-IDoc-to-B2MML integration prompted SAP to ship B2MML content packages [1]; the MES master batch record holds the genealogy this book models as bp:BATCH-2026-001 derivedFrom bp:SEED-001, on out to the released bp:DS-001 and bp:DP-001 lots, but in a vendor-proprietary schema rather than a portable graph; and multivariate CPV over a golden batch runs in commercial tooling, with an ISPE case applying it to a 5,000-L stainless-steel cell-culture batch (a larger, different facility paradigm than this book's 2,000-L single-use mAb-A reactor, though the method is scale-independent) [11]. Piloted: the BioPhorum biomanufacturing ontology was validated at NC State's BTEC as a single OD-probe-calibration proof of concept [6], and the Samsung Biologics and GSK digital twins are real but each scoped to one unit operation and built on hybrid mechanistic and ML models, not formal ontologies [7]. Academic or proposed: MCBO, the NIST digital-twin framework, and the OAGi/NIIMBL IOF Biopharma reference ontologies — BFO- and IOF-grounded, exactly the family this book's bp: graph belongs to — carry no named production deployment yet [8][9][10]. The pattern is consistent: structured and statistical models ship; the formal, shareable semantic layer is the one still arriving.

Key terms

• Formal (OWL) ontology vs. structured model — an OWL ontology is a graph of RDF triples (subject–predicate–object) a reasoner can traverse and infer over; a structured information model (an XML schema) or a statistical model moves or scores data but cannot be reasoned over. This page's whole thesis is which floor systems are which. See Instances and the Graph.
• BFO / IOF Core — the Basic Formal Ontology (the upper ontology this book builds on) and the Industrial Ontology Foundry's mid-level vocabulary; the foundations the academic bioprocess ontologies (and this book's bp: graph) align to.
• FAIR — Findable, Accessible, Interoperable, Reusable; the data-stewardship principles repeatedly named as the chief obstacle to scaling twins, ahead of modeling or math.
• Competency question — a test query an ontology must answer correctly; the book runs its own as validate.py against the ORSD.
• UCUM / QUDT — the units-of-measure standards (Unified Code for Units of Measure; the QUDT units ontology) that give each sosa:Observation a machine-checkable unit.
• ISA-95 / B2MML — the IEC 62264 standard for enterprise-to-control integration and its XML serialization; a structured information model, not a formal ontology, that moves data between ERP and MES.
• Master batch record (MBR) — the electronic recipe an MES executes and the as-executed record it produces, holding batch genealogy in a vendor-proprietary model.
• Continued Process Verification (CPV) — FDA Stage 3 of process validation; on real floors, a multivariate statistical model (PCA/PLS over a golden batch), not a semantic one.
• Golden batch — a reference profile distilled from historically good runs, against which live batches are compared by statistical distance.
• Asset Administration Shell (AAS) — the Industrie 4.0 standardized digital-twin metamodel for an asset's properties and capabilities, piloted for pharma via ISPE.
• SiLA 2 / AnIML — open, royalty-free standards for lab-device connectivity and analytical data, in early piloted deployment.
• OPC UA LADS — OPC 30500, the first OPC UA companion specification for laboratory and analytical devices, demonstrated as proof of concept.
• SOSA/SSN — the W3C/OGC Semantic Sensor Network ontology; the vendor-neutral, formal way to model sensor and PAT telemetry, counterpart to a proprietary asset framework.
• Digital twin — a live computational model of a physical asset; on the biomanufacturing floor today, built on hybrid mechanistic and ML models rather than formal ontologies.
• MCBO — the Mammalian Cell Bioprocessing Ontology, a BFO + IOF Core academic ontology validated on curated cell-culture instances, with no named industrial deployment.
• Grey-box (hybrid) twin — a digital twin whose mechanistic backbone (here qP times the integral of viable cell density) carries the trend while a small network learns only the residual the physics misses; the form the headline bioreactor twins actually take, detailed in the companion ML book.
• Grouped / leave-one-batch-out cross-validation — splitting a learner's evaluation by batch so the held-out fold is a genuinely new run, not leaked timepoints of a training run; the bp:Batch individual is the grouping key, which is why the chapter's batch-individuation problem is also a model-validation problem.
• Applicability domain — a gate that asks whether a new batch resembles the runs a model was trained on, so the model declines to guess out of its depth; the ontology's lineage and unit-bearing telemetry make "out of envelope" a graph query.
• ALCOA+ / Part 11 / Annex 11 — the data-integrity principles and the US/EU electronic-records law that make a batch record and a golden-batch model legally trustworthy; a governed graph makes the same audit trail queryable. See Part 11 / Annex 11.
• CSA (Computer Software Assurance) — the FDA's risk-based successor to CSV: validation depth scales to how much a system influences a release decision, which is why an ontology-grounded twin near a CQA must be qualified, not just modeled.
• Executable ORSD — the book's requirements-as-tests: cq-catalog.json's 23 competency questions run by validate.py as PASS/FAIL, the mechanical check that a lifted floor graph answers what the floor needs.

Where this leads

The floor showed us a frontier where the math is mature and the meaning is still arriving — and it named the missing layer plainly: governed, shared, semantic data. The final chapter asks what becomes possible when that layer finally exists. The next chapter, The Frontier: Ontologies as the Ground Truth for AI, turns from where ontologies are arriving to why their arrival matters most: as the verifiable ground truth that keeps machine learning and large language models honest about a process where being wrong is not an option.