FabOS: A Proven Pattern for Fab Data
FabOS is the pattern we use to bring analytics, machine learning and AI to semiconductor manufacturing: the wafer fab and the advanced materials and critical components that supply it, from specialty chemicals and CMP slurries to high-purity filtration. It joins tool data, lot lineage, metrology and material genealogy in one knowledge graph, then puts statistics, monitoring and models on top.
FabOS is not an off-the-shelf product. Its batch-analytics core runs in production at Entegris: batch impact analysis, variance detection, quality clustering and customer excursion support. Its tool-level layer has been built end to end as a proof of concept: Data Logger pipelines and dashboards, fab flow modeling and data merging. We implement it inside your environment, around your tools and data.
In production
- Batch impact analysis Entegris
- Variance detection Entegris
- Quality clusters of good and bad batches Entegris
- Customer excursion support Entegris
- Unit-to-source-lot traceability Materials manufacturer
- eBOM-to-mBOM supply tracking Lockheed Martin
Proven in POC
- Data Logger pipeline and dashboards
- Intra-reactor statistics and variance
- Fab flow builder with Data Logger attribution
- Metrology and user data for dashboards, monitoring and alerting
- Data merging: map selected datasets to logger traces
Designed, next phase
- Virtual metrology and yield prediction
- Governed plain-language answers
Sources
- Tool Data Logger traces
- MES lot & unit lineage
- Metrology & SPC
- Material & supplier genealogy
Capture & map
- Data Logger pipelines
- Logical fab flow
- Dataset merge & mapping
FabOS core
- Knowledge graph: lineage & context
- Columnar store: traces & maps
- Graph Data Science
Outcomes
- Batch impact & excursions
- Variance & quality clusters
- Dashboards, monitoring & alerts
- Prediction (next phase)
1. The Problem: Fab Evidence Lives in Silos
Every unit of manufacture leaves a trail, but it is scattered. Per-run sensor traces sit on tool PCs in each vendor's own format, often owned by no one. Lot and unit lineage lives in the MES or batch records. Spec limits, SPC and detailed metrology live in an engineering database. Upstream, the materials that went into each batch are tracked in ERP genealogy records. Answering a simple question such as "why did this batch perform so well?" means stitching these together by hand.
The FabOS pattern joins them once, at the right level of identity, so an engineer sees lineage, process context, what the tool actually delivered and how the unit measured, side by side.
2. In Production: Batch Analytics at Entegris
For Entegris, we integrated a knowledge graph and Graph Data Science into the fabrication process. Four capabilities from that work are in production today and form the core of FabOS:
- Batch impact analysis: when a tool, step or material lot is found to be faulty, the graph identifies every batch it touched, so containment is fast and scoped without holding back unaffected product.
- Variance detection: process and quality variance is surfaced across batches, steps and materials, so shifts are visible before they become scrap.
- Quality clusters: batches are grouped into clusters of good and bad outcomes by their shared process and material history, so engineers can see what good batches have in common and where poor ones diverge.
- Customer excursion support: when a customer reports an excursion, the team traces the affected product back through its batches, process history and source lots and answers with evidence.
The Lineage Foundation
Batch analytics depend on lineage. Two further production engagements prove that layer at scale:
- Supply-chain traceability: for a semiconductor materials manufacturer, a knowledge graph powering a Digital Product Passport across multiple manufacturing lines, with 80M+ genealogy relationships, 250M+ sampling records and sub-second traceability from a serialized unit back to its source material lots. Measurements are classified as KPIV/KPOV for process control and yield work.
- eBOM to mBOM: for Lockheed Martin, a supply-chain graph that tracks supplies through engineering and manufacturing bill-of-materials activity, linking what was designed to what is built, alongside Graph Data Science pipelines for demand forecasting.
3. Proven in POC: From Tool Trace to Fab Flow
The production core works at the batch level. The proof of concept extends the same pattern down to the tool, built and tested end to end on synthetic Data Logger data:
- Data Logger pipeline and dashboards: per-run tool traces are captured, parsed into canonical parameters and shown in run-level dashboards.
- Intra-reactor statistics and variance: variance is analyzed within each reactor as well as across runs, so changes in tool behavior show up even when run averages look normal.
- Fab flow builder: users build a logical fab sequence of steps and tools, then attach Data Logger runs to the step that produced them, so every trace sits in its process context.
- Metrology and user data: metrology and other user-provided data join the same flow and feed dashboards, monitoring and alerting.
- Data merging platform: users bring selected datasets into the environment and map them to Data Logger traces, without a custom integration for each source.
4. How It Works: A Knowledge Graph Foundation
Every one of those capabilities depends on context: which unit ran on which tool, with which recipe and materials, and how it measured. FabOS keeps that context in a Neo4j knowledge graph organized in four layers. The graph holds identity, lineage, context and precomputed statistics; high-volume arrays such as sensor traces and inspection maps live in a columnar Parquet store, with every file keyed back to a graph node.
Product-Agnostic by Design
The model is built around a generic unit of manufacture, not a wafer. The same lineage, measurement and decision layers describe very different products; only the unit type and its properties change:
Design Principles
- The tool is never touched. Capture runs beside the tool's control software, never inside it.
- Raw data is immutable, so every analysis can be reproduced from source.
- Read-only access to production MES and engineering databases.
- One canonical parameter per physical quantity, however many vendor formats report it.
- Every link carries its evidence. Each trace is bound to its process step with a method and a confidence score.
5. Next Phase: Prediction and Plain-Language Answers
Two capabilities are designed into the pattern and build directly on the production and POC layers:
- Virtual metrology and yield prediction: deep-learning models on sensor time series and inspection maps, trained on versioned, point-in-time extracts keyed back to the graph, to estimate how a unit will measure and perform with less physical sampling.
- Governed plain-language answers: AI agents that let engineers ask questions such as “Was today's run on Reactor A normal?” or “Trace this finished unit back to every source lot.” The agent fills a structured comparison and a semantic layer generates a bounded query, so answers are reproducible and cite their data.
6. How We Implement It
Each FabOS engagement starts from what is already proven and is built in your environment on your data:
- Data Logger and fab flow — stand up the POC-proven logger pipeline on one or two of your tools and model your fab sequence.
- Lineage and batch analytics — bind runs to lots and batches; switch on the production-proven batch impact, variance and quality-cluster analysis.
- Metrology, merging and alerting — bring in metrology and your selected datasets; set up dashboards, monitoring and alerts.
- Prediction and plain language — extend to virtual metrology, yield models and governed natural-language questions.
Engagements typically begin with a proof-of-efficacy study (about 12 weeks, with success criteria agreed up front) and progress to a durable platform build (about 5–6 months). Everything runs inside your own cloud environment and inherits its security posture.