The ontology

A catalog tells you what data exists. An ontology tells you what it means: the objects your organization actually deals in, how they relate, and what can be done to them.

It sits over the catalog rather than beside it, so an object type is bound to real assets, and a change to the model is a governed catalog change rather than a document somebody updates afterward.

Three type families

Family	What it declares
Object types	The things: a patient, a vessel, a claim, a substation. Bound to catalog assets, with a schema, a primary key, declared behaviours, and the interfaces they implement
Link types	The relationships, with declared source and target types, so the graph is typed rather than inferred
Action types	What may be done, with undo and declared side effects, so an action is a governed operation rather than a write somebody scripted

Around them:

• Constraints, validated rather than documented.
• Derivation rules with their own expression layer, so a derived property is defined once in the model instead of recomputed differently by each consumer.
• Subsets, including edge subsets, for working with a slice of a large model.
• Interfaces and implementors, so several object types can satisfy one contract.
• Evidence types, for models where a fact needs provenance attached to it.

Actions carry undo and side effects

This is the part that separates a modelling layer from a documentation exercise. An action type declares what it changes and what follows from it, and there is a real executor, a side-effect handler and an undo path behind it.

That matters because the alternative, an action implemented as an ad-hoc write, has no reliable inverse and no declared blast radius. Here both are properties of the model, which is also what lets an agent be given an action without being given a shell.

Changing the model is reviewed

An ontology is only as trustworthy as its change process, so changes are staged rather than applied.

Figure: a model change is staged and queued rather than applied. Approve, merge and reject are explicit outcomes, and a merged change extends a verified evolution chain so the model's history is checkable rather than remembered.

Table equivalent

Stage	What happens
Proposed	A change to an object, link or action type is drafted
Staged	It enters a review queue, which reports its own health so a backlog is visible
Review	Approve, merge, or reject, each an explicit outcome
Evolution chain	A merged change extends a verified chain, so the model's lineage is checkable
Consistency and validation	Run against the model rather than trusted

A promotion gate governs an ontology moving between environments, and signed ontology bundles let a model be exported, carried and imported elsewhere, including across an air gap, and verified on import rather than trusted because it arrived.

The model becomes typed code

SDK emitters generate clients from the ontology. A generator drives per-language emitters for Python and TypeScript, alongside an OpenAPI surface, so the customer's object model becomes typed code rather than documentation somebody has to read and then hand-write against.

That is the difference worth stating: when the model changes, the clients are regenerated from it, so drift between the model and the code that uses it is a build step rather than a discovery made in production.

Reaching the graph and the stream

• Graph write-back, so the ontology is not read-only over the graph.
• Stream templates with conflict detection, so a model can declare the real-time shapes it expects.
• Grounding, which is how the ontology informs retrieval and extraction rather than being a diagram nobody consults.
• An ontology subset synchronises to edge devices, so extraction at the point of capture is guided by the same object model the core uses, and a field device structures what it sees against your model rather than a generic one.

Where it is used

Consumer	How
Industry packs	A pack ships a vertical's object, link and action types and registers them
The virtual graph	A property graph projected over lakehouse tables with no copy
Knowledge and semantics	Observation to candidate to canonical entity, guided by the model
Agents	An action type is something an agent can be granted, with its undo and side effects declared
The edge	Ontology-guided entity extraction, offline

Related

• The catalog and lineage, the assets an object type binds to.
• Ontology & SDKs, the generated client surface.
• Environments and promotion, moving a model between environments.
• Knowledge and semantics, the reasoning layer above it.