Most "Ontologies" Don't Reason. Build Yours in the Right Order Anyway.

The short version

• Almost no product on the market meets the formal definition of an ontology, and Jessica Talisman is right to say so. Ours does not meet it either: we build governed graphs of entities, properties, and relations, without formal inference.
• The useful question for a builder is what to build, in what order, so that agents working against your data are trustworthy at each step.
• The answer is a six-rung ladder: a resolved and governed graph, then versioning, inheritance, controlled vocabularies and taxonomies, rules and constraints, and formal inference last. Rungs two and three often land in either order.
• A reasoner is an amplifier. Pointed at an unresolved, unversioned graph, it derives garbage with perfect logical rigor; the lower rungs are its preconditions.
• Ask any vendor which rung they are on today, not which rung their roadmap gestures at.

The word "ontology" is having a moment. Databricks put it in a product name. Palantir built a company on it. Microsoft attached it to Fabric IQ. Snowflake wrapped an architecture in it at their Summit. Databricks? The week after. And shortly thereafter, Jessica Talisman published "Not an Ontology", a careful analysis arguing that none of these products meets the formal definition: "an explicit specification of a conceptualization", in Tom Gruber's classic formulation, which the knowledge-representation tradition completes with axioms and a reasoner that derives new facts. By that bar, she is right. Ranking definitions is not reasoning. Snapshot traversal and pre-declared joins are retrieval and query generation, which are useful and are not the same thing.

I work on zaimler, the runtime context layer for AI agents, so I read her piece with more than academic interest. Her bar would find our platform short too; conceding that plainly is the only credible place to start. We produce governed graphs of entities, properties, and relations. We do not have formal inference. Almost nobody does.

But here is where I part ways with how the debate usually goes from there. The interesting question for a practitioner is not "is it a real ontology?" It is: what should you actually build, in what order, so that agents working against your data are trustworthy at each step along the way? That question has an answer, and the answer is a ladder. You climb it.

(A note on framing: in a follow-up piece I'll look at the five mechanisms vendors actually ship behind the word "ontology": retrieve, rank, generate SQL, traverse, reason. That is a lens for evaluating products. This piece is the other side of it, the path a builder climbs. The two are related but not the same axis: a product runs one mechanism; a builder accumulates structure.)

The false fork: property graph versus RDF

First, a distraction to clear away. Much of this debate collapses into a technology fork: labeled property graphs (fast, pragmatic, vendor-flavored) versus RDF and OWL (open, formal, reasoner-ready). Pick your church.

The fork is a red herring, because the two things do different jobs at different layers. A property graph is a runtime substrate: it is how you materialize a graph and traverse it quickly, multi-hop, at query time. An ontology is a governance layer: it is where classes, properties, and constraints are defined, and it is where open semantic standards belong, because meaning defined in open structure (RDF, OWL, JSON-LD, SKOS) can leave the building. The mature architecture uses both, each where it is strong: an open-standards-aligned model governing what the graph may contain, and a traversal-optimized runtime executing against it.

This matters for Talisman's description of sovereignty, and her framing of it is the one I now use: meaning is only sovereign if it is exportable in open, vendor-neutral structure. A graph whose semantics exist only inside one vendor's runtime fails that test no matter how good the demo is. A runtime graph that is grounded in an open model passes it, because the meaning has an existence independent of the engine. Residency (where the reasoning runs, what leaves your boundary) is the other half of sovereignty, and it deserves equal weight, especially as legal compliance requirements of traceability and oversight obligations take shape. Ask both questions of any platform, including mine.

Climb the ladder in order

Talisman's own Ontology Pipeline is a progressive framework: controlled vocabularies, then taxonomies, then ontologies, then knowledge graphs. I want to offer a practitioner's version of the same instinct, aimed at teams building for agents today. The principle: each rung is only worth building on top of the rung below it. You do not build the fifth floor before the second.

The full arc is below. Rungs two and three often land in either order; everything else sequences strictly. Each rung earns its place the same way: it converts a class of silent failure into governed behavior a business can rely on.

Two rungs deserve a closer look, because they are where I see teams go wrong most often: the bottom and the top.

The bottom rung is unglamorous, and it is where most of the production value lives. Entity resolution is what makes federated consistency possible, where "Customer 4471" in the billing system and "C-4471" in the CRM are one thing, not two. And the human in the loop matters most here: when the system proposes a definition or a relationship, an expert validates it before agents rely on it. Automation that guesses definitions from usage signals produces confident, wrong answers unless a person signs off.

The middle rungs compound quietly. Versioning answers the auditor's question: what did "active member" mean when this answer was generated? Inheritance is what Talisman rightly calls "the most basic ontological relation," and its absence is a fair test of any product using the word (she makes exactly this point about Fabric). SKOS-style concept schemes earn their keep fastest in regulated domains built on canonical code lists. And validation shapes (in the spirit of SHACL) are a bigger day-to-day win than most teams expect, because the moment the graph can push back is the moment it stops being a passive store.

The top rung is the reasoner: axiomatic entailment, deduction. The rung Talisman correctly observes nobody ships. It is only a matter of time before this arrives as a scalable capability in the agentic era. But most teams are not prepared to start there, for a simple reason: reasoning over an unresolved, ungoverned graph just produces confident nonsense faster. A reasoner is an amplifier. Point it at a graph where entities are duplicated, definitions are unvalidated, and nothing is versioned, and it will derive garbage with perfect logical rigor. The lower rungs are not a delay on the way to reasoning. They are its preconditions.

Even a reasoner needs an interpreter

One more layer that the formal debate tends to skip, raised by a commenter on Talisman's piece: even with a working reasoner, outputs have to be interpreted by people who were not in the room when the model was built. Inference does not exempt you from interpretation.

This is why I weigh provenance and human validation so heavily on rung 0. An answer that arrives with its derivation path (these entities, these relationships, these definitions, validated by this person, under this model version) can be interpreted, challenged, and corrected. An answer that arrives bare is a liability even when it is right, and in regulated settings, especially then. It's an open secret that generative models are increasingly shouldering the burden of reasoning in agentic architectures. If production systems are to rely on this reference architecture, then the derivation path is the only part of the answer a human can actually audit.

What I would hold any vendor to, including us

The industry is converging on the right ambitions: sovereign meaning, persistent knowledge infrastructure, semantics a machine can compute with. Talisman is right that the current products stop short of the logic, and right to say so with receipts. The neurosymbolic research consensus (Hitzler et al. is a canonical reference) says the destination is real: symbolic structure supplies the stability, consistency, and explainability that statistical models lack on their own.

So hold every vendor, including the one I work for, to the ladder. Ask which rung they are on today, not which rung their roadmap gestures at. Ask whether meaning can leave their runtime in open structure, and whether it stays inside your boundary at inference time. Ask who validates an inferred definition before an agent uses it. And be suspicious of anyone who claims the top rung; as of this writing, the honest answer from the entire industry is "not yet."

The word "ontology" will keep stretching in whatever direction the next product launch needs. Climb the ladder in order anyway.

Sources and further reading: Jessica Talisman, "Not an Ontology" (Intentional Arrangement, June 2026); Thomas R. Gruber, "A Translation Approach to Portable Ontology Specifications" (1993); W3C Semantic Web standards and SHACL; Hitzler et al., "Neuro-symbolic approaches in artificial intelligence" (National Science Review, 2022); Kent Stoker, "The Squishy World of Context Graphs" (BigDATAwire, June 2026); the Open Semantic Interchange initiative, recently renamed Apache Ossie (Incubating), an open interchange effort worth watching; EU AI Act implementation timeline.