A Living Knowledge Model
The knowledge graph
Atlas runs on a knowledge graph designed to subscribe to live data. This s not a third-party graph database like Neo4j or Amazon Neptune under a manufacturing skin. It is purpose-built for the shape of the problem: millions of objects and relationships that need to be traversed while always knowing current state.
Owning the knowledge graph means no per-node licensing drag, no external cluster to stand up before the first model exists, and an install footprint light enough to run at the edge of a single line or across an enterprise.

why custom, not off the shelf
A generic graph database gives you storage. It does not give you manufacturing semantics, standards libraries, an agent that knows how to model a CIP cycle, or an install profile an OT engineer can deploy without a data-engineering team. Owning the knowledge graph is what lets every layer above it be built for the plant floor rather than adapted to it.
relationships are first-class citizens
the primative
In Atlas a relationship is not an implied parent-child link in a tree and not a foreign key buried in a table. It is modeled exactly the way a node is: a real object with its own type and its own properties.Tank-101 feeds Reactor-3 is a relationship. In Atlas that edge can hold its own properties:
- that the feed only occurs during fermentation
- the flow path it runs through
- the conditions under which it is valid
- the date it was commissioned
It is a queryable, governed thing with structure of its own, which means the operational logic an engineer carries in their head, the part that never fits in a tag name or a topic string, finally has somewhere to live that a query can reach and an agent can reason on.
The flexibility is deliberate. You define the relationship types your operation actually uses, with the properties that matter to you, rather than bending your world to fit a fixed set of hierarchy rules. Two plants can model the same equipment differently because they run differently, and both models are valid.
libraries & governance
the vocabulary
A library is a reusable pack of typed entities and relationships, as well as properties, data types, and functions; all of which can be extended or composed from others.
You choose the standards you want to use... ISA-95 for the enterprise, plant, area, and work-center hierarchy, ISA-88 for batch, recipe, procedure, and phase, ISA-5.1 for parsing instrument tags such as FIC-101 or PSH-202 into structured attributes, ISA-18.2 for alarm management, ISO 15926 for oil and gas asset lifecycle, and CESMII Smart Manufacturing Profiles. You import the standard, and it becomes live ontology in your model.
You also create your own, and this is the bigger idea. A control-module library of valves, motors, and PID loops, a corporate equipment standard, a recipe framework specific to your products. When an organization authors its own libraries, it takes governance over its model: the vocabulary is defined once, owned centrally, and every domain that consumes the library models under it.
Standards give you a proven starting point; your own libraries are how your organization governs what things mean. Once built, a library is reusable across every model that needs it, which is how a standard actually propagates across sites instead of being re-typed at each one.
Domains and how they federate
The governed unit
When you instantiate your various types, creating instances within a model you form a domain. A domain is a self-contained Knowledge Model, independently authenticated and independently governed.
It is where a team actually does its modeling, and it consumes libraries to do so: a process-engineering domain might pull in ISA-88 and a recipe library, a maintenance domain pulls in an equipment-standard library and ISA-18.2, and each team models its own slice of the operation using the vocabulary those libraries provide. They do not need to understand the full enterprise model to contribute correctly to their piece of it.

Git for version control
Models are Git-backed. Every change to the ontology, the instances, and the relationships is versioned, which means a model has history, branches, review, and rollback the same way source code does. For a governance layer this is not a convenience, it is the mechanism: you can answer how the model looked during Batch 47, who changed a definition and when, and you can propose and review a structural change before it goes live. Governance stops being a policy document and becomes an enforced property of the platform.