Ontology Design Patterns Part 6: *Multiple Inheritance, Not Multiple Instantiation*

2026 Is the Year Ontology Breaks Out — And Why Getting It Wrong Is Dangerous Neil Gentleman-Hobbs is spot on. 2026 is the tipping point where enterprises finally realize that AI can’t act intelligently without a semantic foundation. LLMs can produce language, but without ontology they cannot understand anything they output. A while back I wrote the Palantir piece about Alex Karp’s “chips and ontology” quote — and the reaction was huge. Not because Palantir isn’t doing important work, but because there’s a major misunderstanding in the market about what ontology actually is. And here’s the core truth: **Palantir is not doing ontology. They are doing a configurable data model with workflow logic.** Their “ontology” has: • no OWL or CLIF • no TBox or ABox structure • no identity conditions • no logical constraints • no reasoner • no formal semantics at all It’s powerful, yes. It’s useful, yes. But it is not ontology. Why this is dangerous When companies believe they have ontology but instead have a dressed-up data model, three risks emerge: 1. False confidence You think your AI can reason. It can’t. It can only follow whatever imperative code a developer wrote. 2. No logical guarantees Without identity, constraints, and semantics, the system cannot detect contradictions, errors, or impossible states. It hallucinates in a different way — structurally. 3. Brittleness at scale Every new policy or relationship must be coded by hand. That’s not semantic automation, it’s enterprise-scale brute force. This is exactly where systems crack under combinatorial growth. In other words: you don’t get an enterprise brain, you get a beautiful spreadsheet with an API. At Interstellar Semantics, this is the gap we focus on closing: building real ontologies with identity, constraints, time, roles, and reasoning — the kind of foundations AI systems actually depend on. If your organization wants to understand what real ontology looks like: 👉 https://lnkd.in/ek3sssCY #Ontology #SemanticAI #EnterpriseAI #AI2026 #Palantir #SemanticReasoning #KnowledgeGraphs #DataStrategy #AITrustworthiness | 12 comments on LinkedIn

Accounting for How We Work

Summary of the things I learned at the 2025 International Semantic Web Conference, my scientific home.

What is knowledge engineering?

Here it is - the draft of the latest chapter on meaning in data modeling.

Ontologists, rejoice!

The Sketch and The Blueprint

The first in a series of posts about knowledge graphs and ontology design patterns that I swear by. They will lead you through how at Yale we went from a challenge from leadership (build a system that allows discovery of cultural heritage objects across our libraries, archives and museums) to a fully functioning, easy to use, easy to maintain, extremely robust, public knowledge graph. *The 10 Design Principles to Live By* 1. Scope design through shared use cases 2. Design for international use 3. Make easy things easy, complex things possible 4. Avoid dependency on specific technologies 5. Use REST / Don’t break the web / Don’t fear the network 6. Design for JSON-LD, using LOD principles 7. Follow existing standards & best practices, when possible 8. Define success, not failure 9. Separate concerns, keep APIs & systems loosely coupled 10. Address concerns at the right level You must first agree on your design principles and priorities. These are crucial because when the inevitable conflicts of opinion arise, you have a set of neutral requirements to compare the different options against. (1) The first keeps you honest: good ideas are only ideas if they don't advance your business / use cases. Keeping to scope is critical as ontologies have a tendency to expand uncontrollably, reducing usability and maintainability. (2) Internationalization of knowledge is important because your audience and community doesn't just speak your language, or come from your culture. If you limit your language, you limit your potential. (3) Ensure that your in-scope edge cases aren't lost, but that in solving them, you haven't made the core functionality more complicated than it needs to be. If your KG isn't usable, then it won't be used. (4) Don't build for a specific software environment, because that environment is going to change. Probably before you get to production. Locking yourself in is quickest way to obsolescence and oblivion. (5) Don't try to pack everything a consuming application might need into a single package, browsers and apps deal just fine with hundreds of HTTP requests. Especially with web caches. (6) JSON-LD is the serialization to use, as devs use JSON all the time, and those devs need to build applications that consume your knowledge. Usability first! (7) Standards are great... especially as there are so many of them. Don't get all tied up trying to follow a standard that isn't right, but don't invent the wheel unnecessarily. (8) Define the ontology/API, but don't require errors for all other situations, as you've made versioning impossible. Allow extensions to co-exist, as tomorrow they might be core. (9) Don't require a single monolith if you can avoid it. If a consuming app only needs half of the functionality, don't make them implement everything. (10) If there's a problem with the API, don't work around it in the ontology, or vice versa. Solve model problems in the model, vocabulary problems in vocabulary, and API problems in the API. | 12 comments on LinkedIn

A Case Study in Context Engineering & How We Can Apply Learnings In Data Platforms

What if ontology can be better approached as a spectrum?

After a vivid conversation with Juan Sequeda and others at Connected Data London 2025 about how to start with Ontologies at business clients w/o relying on another KG platform, I have now started to roll (eh vibe coding 🤓) my own Ontology Builder as a simple Streamlit app! Have a look and collaborate if you like. https://lnkd.in/egGZJHiP

Simple way of starting with ontologies: start with your favorite LLM and the following prompt:

# ⚙️ Ontology Evolution: When New Knowledge Challenges Old Categories  When new entities don’t fit existing assumptions, your ontology must **evolve logically**, not patch reactively. --- ## 🧩 The Challenge: Going Beyond Binary Thinking  Early models often start simple:   **Appliance → ElectricityConsumer OR NonElectricAppliance** But what happens when a *WindTurbine* appears?  It **produces** more electricity than it consumes.  --- ## 🔧 Step 1: Extend the Energy Role Taxonomy  To reflect the real world:  ``` EnergyRole ├─ ElectricityConsumer ├─ ElectricityProducer   ├─ ElectricityProsumer (both) └─ PassiveComponent (neither) ``` Now we can classify correctly:   - 🏠 HVAC → ElectricityConsumer   - ☀️ Solar Panel → ElectricityProducer   - 🔋 Battery → ElectricityProsumer   - 🪟 Window → PassiveComponent  This simple hierarchy shift restores consistency — every new entity has a logical home. --- ## 🧠 Step 2: Add Axioms for Automated Reasoning  Instead of manual assignment, let the reasoner decide. Example rule set: - If `producesPower consumesPower` → ElectricityProducer   - If `consumesPower producesPower` → ElectricityConsumer   - If both 0 → ElectricityProsumer   - If both = 0 → PassiveComponent  💡 **Outcome:** The system adapts dynamically to new data while preserving logical harmony. --- ## ⚡ Step 3: Support Evolution, Don’t Break History  When expanding ontologies: 1. Preserve backward compatibility — old data must still make sense.   2. Maintain logical consistency — define disjoint and equivalent classes clearly.   3. Enable gradual migration — version and document each model improvement.   4. Use reasoning — automate classification from quantitative features.  Evolution isn’t about tearing down—it’s about **strengthening the structure**. --- ## 🌍 Real-World Analogy  Think of this like upgrading an energy grid:   You don’t replace the whole system — you extend the schema to accommodate solar panels, batteries, and wind farms while ensuring the old consumers still work.  Ontology evolution works the same way — graceful adaptation ensures **stability + intelligence**. --- ## 💬 Key Takeaway  *WindTurbine* example shows why **ontology evolution** is essential:   - Models must expand beyond rigid assumptions.   - Axiomatic rules make adaptation automatic.   - Logic-based flexibility sustains long-term scalability.  In short: **don’t model just the present — model the principles of change.** #Ontology #KnowledgeEngineering #KnowledgeGraphs #ExplainableAI #OntologyEvolution #NeuroSymbolicAI #AITransformation #KnowledgeManagement 👉 Follow me for Knowledge Management and Neuro Symbolic AI daily nuggets. 👉 Join my group for more insights and community discussions [Join the Group](https://lnkd.in/d9Z8-RQd)

Introducing the ONTO-TRON-5000. A personal project that allows users to build their ontologies right from their data! The onto-tron is built with the Basic Formal Ontology (BFO) and Common Core Ontologies (CCO) as semantic frameworks for classification. This program emphasizes the importance of design patterns as best practices for ontology documentation and combines it with machine readability. Simply upload your CSV, set the semantic types of your columns and continuously build your ontology above. The program has 3 options for extraction: RDF, R2RML, and the Mermaid Live Editor syntax if you would like to further develop your design pattern there. Included is a BFO/CCO ontology viewer, allowing you to explore the hierarchy and understand how terms are used- no protege required. This is the alpha version and would love feedback as there is a growing list of features to be added. Included in the README are instructions for manual installation and Docker. Enjoy! https://lnkd.in/ehrDwVrf | 13 comments on LinkedIn

A look at the more subtle aspects of SHACL

Why will 2026 be the year of the ontologist?

I was inspired by a comment on LinkedIn that asks, “How does an ontologist work? How does a day in the life of an ontologist look? What are…

The point of semantic modeling is to capture all of the detail, all of the knowledge, all of the information that becomes available to us. Here is an example of extensive semantic model: ontology plus taxonomies for greater depth. This example is quite a comprehensive semantic model if you consider that it’s supported with nearly 100 sets of definitions and descriptions. The model describes knowledge of many different terms, along with an understanding of how those terms are defined, described, and interrelated. When it becomes difficult to absorb all at once, view it in layers: - Begin with the simple knowledge graph—understand the nodes and the edges, the illustration of things and relationships among them. - Then view the property graph to understand the facts that can be known about each thing and each relationship. - Finally, extend it to include taxonomies to see classes and subclasses. Another approach for layering might begin with the knowledge graph showing things and relationships, then add entity taxonomies to understand classes and subclasses of entities, and finally extend it to see properties and property taxonomies. Don’t shy away from large or complex models! Simply plan to manage that detail and complexity by layering and segmenting the diagram. This provides the ability to look at subsets of the model without losing the comprehensive view of enterprise semantics. Graphic sourced from the ‘Architecture and Design for Data Interoperability’ course by Dave Wells. https://lnkd.in/gtqThWdX

Labels as the Real Semantic Layer of LPG in GraphRAG and Applied Knowledge Graphs

Ontology vs. Conceptual Data Modeling, Implementation of Semantic Foundations, and Using Agents in the Right Places for Enrichment

The Knowledge Infrastructure

Most agentic systems hardcode their capabilities.

Some thoughts about constructing knowledge graphs

I used the o word last week and it hit a few nerves. Ontologies bring context. But then context engineering is very poorly understood. Agent engineers speak about it, expect everyone is doing it, know but almost everyone is winging it. Here's what context engineering is definitely not - ie. longer prompts. What it actually is - the right information, with the right meaning, at the right time. Not more but the right information with the right meaning. Sounds super abstract. That's why a brief video that actually breaks down how to load context. Okay. Not brief. but context needs context.

Most companies think their knowledge graph or ontology will be built by extracting information from their data only to find out that their data doesn’t contain much information. You’re taught the cycle of Data - Information - Knowledge - Wisdom, but they stop before teaching a fundamental concept of information theory. You can measure the information in a dataset. There’s an entire area of study around defining whether a dataset has sufficient information to answer a question and build a model. Run that evaluation on most enterprise data and business questions and you’ll see the extent of the problem. No downstream process (cleaning, transformation, wrangling, etc.) can introduce information that a dataset doesn’t already contain. Said simply, you can’t clean the signal back into the data. If it wasn’t gathered contextually, the information was lost. For almost a decade, I have had to give new clients the same sad story. Roughly 80% of the business’s data doesn’t contain enough information to be used for model training. LLMs don’t change that. Agents need a lot more information to do their jobs reliably. An agent detects intent, then infers the desired outcome and all the steps required to deliver it. RAG over knowledge graphs is intended to provide all the supporting information required to do that reliably. However, if your datasets don’t contain enough information, no amount of AI can fix it. Before building an agent, we must assess whether our data contains enough information to satisfy the range of intents our users will bring to it. That’s an even higher bar than just answering a question or predicting a single variable. Agents create an information problem on both sides of the equation: Do you have enough information to define the intent and outcome based on the user’s prompt? Do you have enough information to define the steps required to deliver the outcome and execute them reliably enough to deliver the outcome? Information and knowledge management are the keys that unlock AI’s value, but businesses must curate datasets in new ways to succeed. The enterprise’s BI datasets and data warehouses rarely contain enough information to get the job done. | 24 comments on LinkedIn

Ontologies transcend their traditional role as static schema documentation and emerge as dynamic, executable metadata that actively controls and defines the capabilities of AI agents. 🔳 They're storing the instructions agents use to operate on that data. Traditional software architectures separate code from data, with logic hardcoded in application layers while data resides in storage layers. The ontology-based approach fundamentally challenges this separation by storing behavioral rules and tool definitions as graph data that agents actively query during execution. Ontologies in these systems operate as runtime-queryable metadata rather than compile-time specifications This is meta-programming at the database level, and the technical implications are profound: Traditional approach: Your agent has hardcoded tools. Each tool is a Python function that knows exactly what query to run, which entity types to expect, and how to navigate relationships. Ontology-as-meta-tool approach: Your agent has THREE generic tools that query the ontology at runtime to figure out how to operate. Here's the technical breakdown: Tool 1 does semantic search and returns mixed entity types (could be Artist nodes, Subject nodes, whatever matches the vector similarity). Tool 2 queries the ontology: "For this entity type, what property serves as the unique identifier?" The ontology responds because properties are marked with "inverseFunctional" annotations. Now the agent knows how to retrieve specific instances. Tool 3 queries the ontology again: "Which relationships from this entity type are marked as contextualizing?" The ontology returns relationship types. The agent then constructs a dynamic Cypher query using those relationship types as parameters. The breakthrough: The same three tools work for ANY domain. Swap the art gallery ontology for a medical ontology, and the agent adapts instantly because it's reading navigation rules from the graph, not from code. This is self-referential architecture. The system queries its own structure to determine its own behavior. The ontology becomes executable metadata - not documentation about the system, but instructions that drive the system. The technical pattern: Store tool definitions as (:Tool) nodes with Cypher implementations as properties Mark relationships with custom annotations (contextualizing: true/false) Mark properties with OWL annotations (inverseFunctional for identifiers) Agent queries these annotations at runtime to construct dynamic queries Result: You move from procedural logic (IF entity_type == "Artist" THEN...) to declarative logic (query the ontology to learn the rules). The system can now analyze its own schema, identify missing capabilities, and propose new tool definitions. It's not just configurable - it's introspective. What technical patterns have you found for making agent capabilities declarative rather than hardcoded? | 37 comments on LinkedIn

𝙏𝙝𝙤𝙪𝙜𝙝𝙩 𝙛𝙤𝙧 𝙩𝙝𝙚 𝘿𝙖𝙮: Why Ontologies Are More Critical Than Ever