GraphNews

Most teams treat OWL and SHACL as design-phase paperwork. Ship the ontology, archive it, let the agent improvise at runtime. ⭕️ The teams shipping reliable agents do the opposite. The reasoner lives inside the loop. An agent proposes an action: cancel a reservation, modify a record, write a triple. Before execution, the harness calls an automated reasoner against the OWL ontology and a SHACL shape graph. Three possible answers. PROOF it respects policy. PROOF it violates a constraint. UNDEFINED. PROOF answers are derivations a domain expert can read line by line. This is what Amazon Neptune demonstrated at KGC 2026. KG-based validation as a steering hook for agentic guardrails. The outcome steers the next step: execute, generate an alternative, or escalate. The same shape graph governs design-time ontology review and runtime writes. The graph is the terrain, the LLM is the explorer. The explorer walks a network with structure. Every step is constrained by the edges that exist and the typed relationships permitted. That structure is what makes agent reasoning inspectable by a clinician, an auditor, a regulator. The equation that lands: OWL Inference × SHACL Validation × Mid-Loop Call = Pre-Mutation Proof LLMs got better at function calling. They did not get better at proving that a function call respects the domain model. AWS Automated Reasoning Checks, Amazon Neptune AgentCore guardrails, OWL DL reasoners, SHACL 1.2 rules. These compose with LLM generation to produce a verified output, not a hopeful one. The cost equation favors it. A reasoner call before every mutating action raises per-step cost. It lowers the voting budget for million-step reliability by an order of magnitude, because invalid candidates leave the pool before the vote. Five layers ship in production. T-Box is the agent's world model. A-Box is its knowledge base. Inference materializes what the agent implicitly knows. S-Box gates writes. Reports give the auditor the line-by-line trail. The 2024 substitution question is dead. "Will LLMs replace knowledge graphs" presupposed competition between layers that compose. The 2026 question is what structure the LLM needs before any team trusts it with a regulated decision. The answer sits in twenty years of W3C standards, finally reaching the runtime. Build the ontology. Wire the reasoner into the harness. Validate every mutating action against the shape graph. Ship what survives all three.

Is a Knowledge Graph a Digital Twin of a Use Case  This is a powerful question and one worth unpacking carefully.  Short answer   No, but the analogy makes sense if you understand the limits. A knowledge graph is not a digital twin of a use case, but a well designed graph can serve as the **semantic backbone** of a digital twin. A use case can be expressed as a set of **competency questions** that the graph must answer.  What is a Digital Twin   A digital twin is a **dynamic real time mirror** of a physical system process or product.  Key traits  - Continuous synchronisation via real time data feeds   - Simulation and prediction capabilities for what if scenarios   - Bidirectional control where system changes can influence the physical environment   - Focused on a specific asset or process such as a factory an energy plant or an industrial robot  What is a Knowledge Graph   A knowledge graph is a **semantic interconnected model** of entities and relationships, typically built from static or slowly changing data.  Core characteristics  - Resolves identifiers and schemas across data silos   - Enables reasoning and causal inference   - Provides deterministic answers to competency questions   - Updated periodically rather than continuously  ## Digital Twin of a Use Case   A **use case** describes a scenario or requirement. A **digital twin of a use case** would be a dynamic executable model that mirrors that scenario and can simulate outcomes.  A knowledge graph could be the **core semantic layer** of such a twin, but the twin would also need   - Streaming data pipelines   - Predictive or probabilistic models   - Feedback loops and control components  When a Knowledge Graph is Like a Digital Twin   - **Static twin snapshot** When you freeze the data at a specific time the graph becomes a snapshot of domain state that you can interrogate for deterministic analysis   - **Deterministic simulation** Through property paths and reasoning you can test what if cases and causal impacts, though not in real time  When a Knowledge Graph is Not a Digital Twin   - Lacks inherent time dimension for dynamic updates   - Lacks continuous real time data feed   - Does not directly actuate or control systems   - Contains no built in predictive engine or simulation loop  The Better Framing   A knowledge graph should be seen as a **deterministic and queryable semantic model** that forms the **intelligent layer of a digital twin architecture**.  👉 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)  #KnowledgeGraphs #DigitalTwins #OntologyEngineering #SemanticAI #KnowledgeManagement #DataGovernance #ExplainableAI #AIEngineering #DataIntegration #CPS #SmartSystems #NeuroSymbolicAI #DigitalTransformation #GraphTechnology

The Ontologist | Kurt Cagle & Chloe Shannon

One of the biggest challenges in Graph Retrieval Augmented Generation (RAG) systems is how to communicate knowledge from the ontology (e.g., subclasses, types, property values) to the LLM. The approach described in this post is very simple and easy to reuse but surprisingly effective.

I think the market is waking up to the problem of tacit knowledge, or at least research is. I’m seeing more research papers mention it now, and that feels significant. So much of what we do remains in our brains, bodies, habits, teams, tools, and environments. Much of it never gets formally documented, and that is a huge problem for AI. But we have to be careful how we define tacit knowledge, even when it appears in the title of a research paper. This paper is not capturing the situated judgement of an expert operating inside a messy live environment. It is extracting and inferring implicit procedural knowledge around tasks: tools, artefacts, prerequisites, warnings, constraints, and missing steps. That is still useful. They are right that LLMs alone are a poor vehicle for this. Unconstrained generation will either miss what is implicit or invent structure that feels plausible. Their solution is sensible: constrain the model with an ontology, preserve provenance, separate explicit observations from inferred assumptions, and require justifications for inferred elements. That is exactly the kind of control layer needed if AI is going to touch knowledge transfer. They are also right that explicit documentation is often procedurally incomplete. A novice can follow the written steps and still fail because the real work depends on unstated conditions: pressure, sequence, tool choice, alignment, warning signs, material behaviour, and the feel of whether something is seated correctly. The paper has a useful handle on that problem. Where I think it is weaker is the concept of tacit knowledge itself. Much of what it calls tacit knowledge is more accurately recoverable implicit knowledge. “Use tweezers for a small bracket” is not the same category as a senior technician sensing that a part is about to shear, or knowing from vibration, resistance, smell, sound, or past failure patterns that the documented procedure should be paused. The system can infer typical missing conditions. It cannot reliably extract the lived judgement of expertise. Tacit knowledge is not simply undocumented information waiting to be formalised. Some of it only exists in practice, under conditions of participation, feedback, apprenticeship, repetition, and context. Once you convert it into a knowledge graph, you have captured a representation of the knowledge, not the knowledge itself. That distinction matters because AI programmes will increasingly be tempted to treat extraction as transfer. They are not the same thing. The useful move is not pretending tacit knowledge has been solved, but building systems that show what was observed, what was inferred, what needs verification, and where human expertise still carries the work. Tacit knowledge is not a database problem. But some of its shadows can be made visible. | 20 comments on LinkedIn

From the author

Context is the brain of AI. Gartner analyst Rita Sallam added context with semantic coherence will become a cost-control and trust strategy, not a nice-to-have. More here. #GartnerDA #Semantics #AI

The 𝐦𝐨𝐬𝐭 𝐟𝐮𝐧𝐝𝐚𝐦𝐞𝐧𝐭𝐚𝐥 𝐮𝐧𝐢𝐭 𝐨𝐟 "𝐮𝐧𝐝𝐞𝐫𝐬𝐭𝐚𝐧𝐝𝐢𝐧𝐠" couldn't be simpler than how RDF defines it. One semantic relationship: how A relates to B. But how do we build this understanding at scale? All data infrastructures in the world have heavy investments backing them. Picture everything from ingestion pipelines and lakehouse architectures to governance frameworks and metadata management. Then an AI initiative lands and the first question is: "Does our data actually mean anything to a machine?" Usually, the answer is: not without a lot of manual wiring. RDF is part of how you solve this architecture problem. 𝐖𝐡𝐚𝐭 𝐢𝐬 𝐑𝐃𝐅 (per W3C) RDF is a W3C standard framework for representing information on the Web. Its data model is built entirely on triples: Subject → Predicate → Object "Order_4821" → "belongs_to" → "Customer_99" "Customer_99" → "operates_in" → "Region_APAC" Chain enough triples and you have a graph that a machine can traverse, reason over, and use as grounded context. 𝐓𝐡𝐞 𝐖3𝐂 𝐬𝐭𝐚𝐜𝐤 𝐨𝐧 𝐭𝐨𝐩 𝐨𝐟 𝐑𝐃𝐅 𝐢𝐧𝐜𝐥𝐮𝐝𝐞𝐬: → SPARQL: the standard query language for RDF graphs, built for relationship traversal the relational model wasn't designed for → OWL: a computational logic-based language that lets machines not just store knowledge, but actively reason and infer from it → SHACL: the W3C standard for describing and validating the shape of RDF data, enforcing structural contracts on your graphs → RDFS: a vocabulary, in RDF, that explains how nodes of a graph relate. LLMs are powerful but context-blind outside their training data. 𝐈𝐧𝐜𝐫𝐞𝐚𝐬𝐢𝐧𝐠 𝐢𝐧𝐭𝐞𝐫𝐞𝐬𝐭 𝐢𝐧 𝐀𝐩𝐚𝐜𝐡𝐞 𝐉𝐞𝐧𝐚, 𝐒𝐇𝐀𝐂𝐋, 𝐚𝐧𝐝 𝐅𝐈𝐁𝐎 over the past few months signals that enterprises are building this semantic backbone now. 𝐓𝐡𝐞 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐚𝐥 𝐬𝐡𝐢𝐟𝐭 Data platforms that serve AI well are semantically aware. That means 𝐝𝐞𝐬𝐢𝐠𝐧𝐢𝐧𝐠 𝐝𝐞𝐥𝐢𝐛𝐞𝐫𝐚𝐭𝐞𝐥𝐲 𝐟𝐨𝐫: → Ontology management alongside data modelling → Knowledge graph layers above your lakehouse → Metadata that carries lineage alongside meaning Building successful AI pods at scale requires focusing on the feed that goes into AI. Are you factoring these semantic necessities into platform design? #DataArchitecture #KnowledgeGraph #SemanticWeb | 21 comments on LinkedIn

Adaptive Graph RAG A Framework for Knowledge Graph Quality, Consistency, and Evolution This article is the full transcript of my presentation at NODES AI 2026. To watch it on Youtube …

Knowledge Graph Health Assessment — Part 1: Structure Defining Foundational Capability for Adaptive Graph RAG 1. Why Knowledge Graph Health Matters Traditional data quality frameworks often focus …

From connected graphs to trustworthy meaning for Adaptive Graph RAG

🚨 Can we trust ontologies generated by LLMs? Large Language Models are becoming powerful assistants for Knowledge Graph and Ontology Engineering. But when they generate ontologies, they can also introduce subtle — and sometimes critical — modeling mistakes. At the LLM-driven Knowledge Graph and Ontology Engineering Workshop (LLM4KGOE), co-located with ESWC - European Semantic Web Conference , I have just presented: “Pitfalls in AI-Generated Ontologies: Strategies for Detection and Mitigation” where I discuss how to move from enthusiasm to reliability when using LLMs for ontology engineering, with two concrete outcomes: ✅ Ontology Pitfalls Detector A new open-source tool that detects mistakes in LLM-generated ontologies. GitHub: https://lnkd.in/e3zeSdjb ✅ Ontology Toolkit by Lettria A platform for automatically building ontologies from documents — while avoiding common ontology design mistakes. Try it: https://lnkd.in/eWnDfFES LLMs can accelerate ontology engineering, but quality assurance must be built into the workflow from the start. Slides are available at https://lnkd.in/edTnwrJK Looking forward to further discussing pitfalls, validation strategies, and trustworthy ontology generation with the ESWC community! Joint work with Pasquale Lisena, Julien PLU, Oscar Moreno Escobar and Edouard Trouillez in the context of #LettRAGraph / EURECOM and Lettria #ESWC2026 #LLMs #KnowledgeGraphs #OntologyEngineering #SemanticWeb #AI #GenerativeAI #ResponsibleAI #KnowledgeRepresentation

The next big category in marketing will not be another AI visibility dashboard. It will be the system of record for brand evidence.

First-Order Predicate Logic is quietly breaking enterprise semantics. And most people don’t realise it. FOPL assumes meaning can be expressed as predicates applied to entities: subject → predicate → object That works beautifully in theory. It fails in practice. Because the predicate is where ambiguity hides. Take something simple: account → hasType → savings Looks clean. Looks logical. But what is “account”? What is “type”? What exactly is being classified? The predicate gives the illusion of structure, while allowing the underlying concepts to remain unresolved. And that’s the problem. FOPL lets you connect things without forcing you to define them. So you can build vast semantic graphs where: – entities carry multiple meanings – predicates encode multiple dimensions – relationships look precise but aren’t disjoint It scales connections. Not clarity. At small scale, humans compensate. At enterprise scale, the ambiguity compounds. At AI scale, it becomes operational. Because the system doesn’t interpret. It executes. This is why so many ontology-driven systems feel coherent but behave inconsistently. The logic is valid. The meaning isn’t. The root issue isn’t tooling. It’s the model of representation. If meaning isn’t atomic—single, disjoint, non-overlapping—no amount of predicates will fix it. They will only make it easier to multiply ambiguity at scale. So the problem isn’t that we need better or more types of predicates. It’s that the predicate itself allows us to avoid resolving meaning in the first place. And that’s why it breaks when you try to scale. You don’t fix that by adding more logic. You fix it by removing the need for interpretation. At that point, the predicate stops being useful. Because the meaning no longer needs to be inferred from relationships. It is already resolved. | 51 comments on LinkedIn

A Recap of Stop Betting, Start Building from The Knowledge Graph Conference

Multi-hop reasoning (MHR) is a process in artificial intelligence and natural language processing where a system needs to make multiple inferential steps to arrive at a conclusion or answer. In...