GraphNews

Why CDM, Ontology, and Knowledge Graphs Matter for AI Agents

The Global Knowledge Graph Market was valued at USD 1 34 billion in 2025 and is expected to reach USD 19 16 billion by 2035 growing at a CAGR of 30 8 during the forecast period 2026 2035 Growth is ...

Switchboards to Subgraphs: Building a Triage Agent on a Neo4j Knowledge Graph How connected expertise lets a Neo4j Aura Agent route tickets the way your best support lead would The French called them …

Business intelligence (BI) on knowledge graphs (KG) is still painful. Most graph databases were built for traversal, not aggregation. That distinction matters enormously the moment you try to do anything resembling BI, reporting or dashboarding on top of them. The problem is structural 'cause BI tools like Tableau, Microsoft Power BI, Metabase, Looker... all speak SQL. They expect rows and columns, group-by, window functions and a query planner that knows how to optimize count-distinct over millions of records. Graph databases speak Cypher, Gremlin, or SPARQL. Brilliant for path finding but terrible for something like "give me revenue by product category over the last quarter". The classic workaround is to replicate your graph into a relational warehouse and query there. Which works, right up until your graph changes and your ETL pipeline needs to be updated. Neo4j's NeoDash is the notable exception. It was built specifically to render graph data as dashboards, all driven by Cypher queries against a live Neo4j instance. No translation layer, no sync lag. It understands that a graph query can return a table if you shape it right, and it lets you do exactly that. For Neo4j shops, it genuinely closes the gap. Very cool. If you're not a Neo4j shop, you're on your own. Hybrid databases like ArcadeDB and SurrealDB have an advantage here. Both support multiple query languages natively (including SQL) over the same underlying graph data. That means your graph nodes are also SQL-queryable rows. Standard BI connectors can speak directly to them. You don't need to export, replicate, or translate. It's an overlooked advantage of hybrid systems. Of course, it's not a perfect story. SQL over a graph is still an impedance mismatch under the hood. Joins don't think in paths and you lose the expressiveness that made you choose a graph model in the first place. For dashboards, KPIs, and operational reporting, it's often good enough. The deeper issue is that the tooling ecosystem hasn't caught up with the data model. Most organizations adopting knowledge graphs end up maintaining two parallel stacks: one for graph intelligence, one for reporting. Until BI tools natively understand graph primitives or until graph databases get serious about analytical query planning this friction isn't going away. Arcade: https://arcadedb.com Surreal: https://surrealdb.com NeoDash: https://lnkd.in/eZT4ZS2M #BI #GraphDatabases #Neo4j #SurrealDB #ArcadeDB | 10 comments on LinkedIn

BioMedima empowers healthcare and life sciences organizations to adopt sustainable and efficient digital practices through the use of knowledge graphs and innovative graph-thinking. By offering a Knowledge-as-a-Service model, it enables organizations to better integrate and utilize data while promoting sovereignty and long-term innovation. At its core, BioMedima focuses on transforming challenges into opportunities by introducing fresh perspectives, graph-thinking experts and cutting-edge digital solutions.

Here's a puzzle: was Pluto a planet? In a knowledge graph, the answer depends entirely on when you ask the question and most graphs can't tell the difference. This is the temporal paradox problem, and it's weirder than it looks. ❖ The Retroactive Truth In 2006, the IAU demoted Pluto. But all those textbooks written before 2006? They were correct when written. A naive knowledge graph that just stores (Pluto - isA - Planet) and then updates it to (isA - DwarfPlanet) has silently erased a historical truth. Your graph doesn't lie, it forgets. ❖ The Schrödinger CEO You ingest a corporate dataset. It says (Alice - isCEO - Acme Corp). Six months later you ingest a new dataset that says (Bob - isCEO - Acme Corp). Was Alice fired? Did she resign? Are both facts true (co-CEOs)? Or is one dataset simply stale? Without time-stamped edges, your graph is a superposition of realities. The moment you query it, you collapse it into a single answer and it might be the wrong one. Side note, such an exciting thought one could model quantum fields as a knowledge graph 🤔 ❖ The Grandfather Contradiction Country borders change. (Kosovo - isPartOf - Serbia) was a valid triple. So was (Kosovo - isPartOf - Yugoslavia) before that. And now neither is true in the same sense. A graph that chains inferences across these facts can derive conclusions that were never simultaneously true.A logical grandfather paradox baked right into your ontology. So how do you fix it? There are a couple of elegant solutions. There is bitemporal modeling: track two timestamps on every edge: valid time (when was this true in the world?) and transaction time (when did you record it?). They're not the same, and confusing them is the root of most graph temporal bugs. You have named graphs + RDF*: wrap facts in a context node that carries provenance, validity windows, and confidence. Query the context, not just the triple. There is event-based reification: instead of (Alice - isCEO -Acme), model the appointment event: a node with a start date, an end date, and a source. Relationships become first-class citizens. Some databases like TerminusDB and TigerGraph's temporal extension, have temporal query layers. They let you query "what did the graph believe on date X?" hence separating knowledge history from world history. The insight is this: a knowledge graph without time is a photograph pretending to be a film. Reality is dynamic, it's a process, not a state. The most dangerous knowledge graph is one that looks authoritative but has silently flattened four dimensions into two. #KnowledgeGraphs #GraphDatabases #TerminusDB #TigerGraph | 12 comments on LinkedIn

There's a something that knowledge graph practitioners almost never talk about but probably should: the topology of ignorance. Known unknowns versus unknown unknowns in RDF. They look very different. A known unknown has a visible shape in your KG. It's a node with no edges, a literal 'null' where a value should be. It's a SPARQL query that returns nothing because the triple doesn't exist yet. You know the gap is there and you can even query for it. An unknown unknown on the other hand leaves no traces. It's the drug-protein interaction your graph never modeled because nobody thought to look. It's the relationship between two clusters that are each well-connected internally but are never bridged. The absence isn't visible, only the expected density that isn't there. Why does this matter practically? Because most KG validation (SHACL, SPARQL constraints, cardinality checks) is built entirely around known unknowns. We check for what we expect to be present. But the highest-value discoveries in any knowledge graph (the unexpected connections, the missing links that change everything) live in unknown unknown territory. We have almost no tooling for finding them. We (only) have human experts and given time and attention, they detect it. The complement graph, the structural holes, the density gradients at domain boundaries... these are the shapes of what we don't know. There are no centrality measures for something that ain't there. One direction worth watching though is persistent homology. Borrowed from topological data analysis, it tracks voids in a graph as you vary a confidence or weight threshold. A hole that appears and disappears quickly is probably noise. A hole that persists across many thresholds is a stable absence. It's a region of the graph that the data consistently fails to connect, no matter how you filter it. That's a different kind of signal than anything SPARQL can surface. Little known, little used, but a fascinating topic worth looking at. Ignorance and uncertainty (yes, I know it's old, but it still is a great reference): https://lnkd.in/eK9zF7gH  Agnotology, the study of ignorance: https://lnkd.in/ea3hgsV8 #RDF #Semantics #KnowledgeGraphs

A practical architecture for semantic mapping, precise retrieval, impact analysis, and intelligent delivery

Build a unified memory (knowledge graph or an LLM wiki) and serve it over MCP servers or skills, so any agent, open or closed, plugs in within minutes.

[Editor's Note] I have been running The Cagle Report [TCR] on LinkedIn for several years now. Increasingly, however, my other newsletters (The Ontologist, The Inference Engineer, The Confabulist, AI Newsbytes) are on SubStack, and I've decided to start publishing The Cagle Report there as well.

Defends ontology enginering as a specific tradecraft focused on addressing interoperability challenges and improving data quality by systematically disambiguating information.

Ontologies aren't system models 🧩 Another great exchange with Nicolas Figay on my cathedrals post (link in comments) that has crystallised a source continuing dissonance between traditional knowledge management and my POV from 30+ years of building systems. Nicolas made a great point that brought it to the surface: "decomposing into micro-ontologies doesn't automatically give you coherence at scale. You can't just aggregate small models and get system-wide interoperability." He's abs. right, but here's the thing: The reason you can't get there by aggregating ontologies - micro or otherwise, is that IMHO ontologies aren't the right tool for modelling systems in the first place. Controversial I know. 🖧 Ontologies are about meaning, they tells you what things are - and they're great at doing this. 🔄 A process model tells you what things do, i.e. about interaction. These are fundamentally different perspectives, and I consistently see the conflating of the two. If you want holistic coherence across an evolving system, the tools already exist and they're mature: state machines, flows diagrams, activity diagrams, interaction models etc. These are the lingua franca of systems that evolve. They model how bounded contexts talk to each other, what state gets handed off, and what the expected outcomes are. Ontologies are a feature of these interactions - they carry the meaning - but they are not great a modelling the interaction itself. 🚧 The conflation trap I've seen it too many times: the usage of an ontology gets conflated with the ontology itself. i.e. "If you don't follow this process, using this standard, to model in this way, then you don't have an ontology." That fundamentally isn't true and is the librarian, not system builder mindset. It risks building a "Cathedral of Beautiful Logic" rather than an outcome based decisioning system. An ontology is an artefact of meaning, it's general purpose, you can apply it to any use case. If you try to model interactions, you're asking it to be something it isn't good at and you're back to building cathedrals. 🎯 Where coherence actually lives Consistency at the holistic level isn't about whether all your ontologies align. It's about whether the outcomes of interacting systems and processes map to what's expected and controlled within tolerance. That's an interaction, not a meaning problem which is so important when designing AI and Agentic decisioning systems as they are about interaction and outcome. Micro-ontologies sit inside each function as a bridge, and I use them for meaning at the point of agentic execution. The holistic view sits above, in how those functions interact to the outcome, hand off state, and reconcile at the seams. - Different tools. - Different perspectives. - Different layers. 📐 The principle: 🖧Ontologies govern meaning. 🔄Interaction models govern systems. Asking one to do the other's job is how you get cathedrals not outcomes. Nebulyx AI | 123 comments on LinkedIn

Free resources for people who build and publish knowledge graphs: ✅ FOOPS! — validates your ontology against the FAIR principles. From the Ontology Engineering Group (UPM) in Madrid. https://lnkd.in/e3nShDat 📄 OnToology — auto-generates documentation and evaluation for ontologies hosted on GitHub, also from the OEG. https://lnkd.in/er_QE9tQ 📚 VocBench — web-based, multilingual, collaborative platform for managing OWL ontologies, SKOS thesauri, and Ontolex-lemon lexicons. Used by the EU Publications Office. https://lnkd.in/eyz6Ucqy 🐍 OWL-RL — Python library implementing OWL 2 RL and RDFS forward-chaining inference over RDFLib graphs. https://lnkd.in/edDX6EFy ⚙️ RDFSharp — modular .NET library for building Semantic Web applications: RDF modeling, SHACL validation, and SPARQL querying. https://lnkd.in/esF4zaeF 🔄 KGX — Python library and CLI for converting and validating knowledge graphs conforming to the Biolink Model. https://lnkd.in/eepXus-U 🕸️ And graph databases, properly covered — the catalog now spans 59 of them, like Dgraph Labs, TerminusDB, ArcadeDB, and NebulaGraph, powered by Vesoft. https://lnkd.in/eSv4kgzC That's 212 tools across 10 categories, alongside 2,012 ontologies, vocabularies, and graphs.

Learn how to engineer a graph ontology that keeps its meaning across RDF and property graph systems, with practical modelling best practices and tooling.

How Graphify Makes Al Coding Smarter (And Cheaper) The first expensive thing Codex (and we guess, any other similar software, like Claude) does in a large codebase is not writing code (and not even …

After five years, I'm making the hard call to wind down Graphlit. I've tried to write that sentence a dozen ways. There isn't a clever version. I'm sad about it. I'm also proud of the work. We were early. Over five years ago, we started as Unstruk Data, with a team around a thesis we called "Snowflake for unstructured data." The words changed, but the need kept getting clearer: AI systems are only as useful as the business context they can connect to, understand, and act on. As GenAI and RAG became real, we leaned into ingestion, extraction, retrieval, and a knowledge graph with temporal facts. Then we built the agent layer on top: durable runs, managed tools, hosted MCP, channels, write-back, and app surfaces for developers, teams, and customer-facing workflows. Graphlit became a production AI context and agent platform: 50+ data/source integrations, retrieval and GraphRAG, a temporal knowledge graph, an AI gateway across 25+ model and service providers, and durable agent infrastructure. It has run as a managed platform with paying customers since 2023. I especially hope Durable Agents doesn't get lost. The market is converging on this shape: Slack-native teammates, managed runtimes, durable frameworks, and messaging-first agents. Durable Agents was the unbundled version: model-neutral, channel-neutral agents with API/CLI/SDKs, event streams, replay, pause/resume/cancel, hosted MCP/tools, channels, and a Library/VFS over connected business data. I wanted to refocus around that platform with Graphlit's context graph under the hood. We ran out of time, but I still think it was right. And still, we're winding it down. The product worked. Customers ran it in production, built apps on it, and gave generous feedback right to the end. What I couldn't do was turn that into a profitable, scalable business. This is a hard market, with strong companies that have better distribution, larger teams, and far more capital. There is also a real commercial challenge: people understand paying for tokens and model usage; paying for a platform layer on top is harder unless value, buyer, and distribution all line up. That's not a complaint. It's the lesson. I'm grateful to the early Unstruk Data team, the contractors and collaborators who helped in the Graphlit years, the investors who backed the vision, and the customers who trusted us with important workflows. The technology and IP are available for the right buyer as an asset purchase. Not because that was the plan, and not because this is a victory lap. Because the work is real, the problem still matters, and I'd rather see Graphlit land somewhere with the resources to keep building on it than let it disappear. If you're building in this space and think Graphlit could be useful to you, send me a DM or email kirk@graphlit.com. Thank you to everyone who followed along, tried the product, shipped with it, gave feedback, reported bugs, or rooted for us. It meant more than you know. - Kirk | 26 comments on LinkedIn

Turning domain knowledge into governed, executable, and auditable decision logic

The Market Distraction Recently, major data platforms (e.g.

When you extract a knowledge graph from a document, what you feed the model matters more than which model you use. In fact, small models perform usually better than larger ones. Thinking models, in particular, are slow and they analyze rather than extract. Raw text is dense, co-referential, and context-dependent. Sentences refer to things like "it", "the company", "this approach"... entities that only resolve if you've read the paragraph before. Feed that directly to an extractor and you get ambiguous predicates, dangling references, and relations that fall apart outside their original context. Atomic proposition extraction is a pre-processing step that fixes this. Before any triple is produced, the document is decomposed into minimal, self-contained claims, each expressing exactly one fact, with all pronouns and references resolved to their full entity names. The extractor then operates on units that are already semantically isolated. Something like KGGen, a Stanford pipeline built on top of DSPy, achieves 66% extraction accuracy this way. The improvement comes not from a better extraction prompt, but from the structure of the input. Decontextualization (creating a self-contained chunk) is the step most implementations skip or underestimate. It requires a sliding context window. Each chunk is resolved against prior material before extraction begins. If done well, it enables parallelization and cutting wall-clock time significantly. On the model side, latent reasoning optimization (LaTRO) offers a complementary lever. Rather than relying on chain-of-thought prompting or external reward signals, LaTRO treats reasoning as sampling from a latent distribution and optimizes it variationally hence improving both reasoning quality and self-evaluation in a single training loop. Applied to the extraction step, it can sharpen triple inference from propositions without touching the pipeline structure. For temporal knowledge graphs, Graphiti takes this further by attaching validity intervals to each extracted fact, enabling the graph to represent a world that changes over time rather than a static snapshot. LaTRO: https://lnkd.in/euTRcitm Graphiti: https://lnkd.in/ega9Esbi DSPy: https://dspy.ai/ #KnowledgeGraphs #Ontology

Taxonomy vs Ontology vs Semantic Mapping vs Knowledge Graph. I see these terms getting mixed up a lot in enterprise AI and data architecture discussions. They sound similar, but they are solving different problems. The way I look at it: Taxonomy = organize the information It gives a clean structure. Example: Product Electronics Laptop Ultrabook It helps with classification, navigation, reporting, and standardization. Ontology = define the meaning It explains the concepts, properties, and relationships. Example: Customer places an order Order contains Product Product belongs to Category This is where the business meaning starts to become clear. Semantic Mapping = align different systems Most enterprises have the same concept stored in different ways across systems. Example: CRM says Customer ERP says Client Support system says Account Semantic mapping connects these terms to a common business meaning. Knowledge Graph = activate the connected knowledge This is where entities and relationships come together as a network. Example: Customer → placed → Order Order → contains → Product Product → belongs to → Category Customer → raised → Support Ticket Now AI systems can use the relationships, not just isolated records. That is the important part. A knowledge graph is not just a graph database. Without proper taxonomy, ontology, and semantic mapping, it can easily become another messy data layer. For enterprise AI, especially RAG, agents, semantic search, recommendation, and decision intelligence, this foundation matters a lot. To sum it up in one line each: Taxonomy organizes the structure. Ontology defines the meaning. Semantic mapping aligns across systems. Knowledge graph connects everything into usable context. This is how scattered enterprise data starts becoming usable enterprise knowledge. #EnterpriseAI #KnowledgeGraph #Ontology #Taxonomy #SemanticMapping #DataArchitecture #AIArchitecture | 28 comments on LinkedIn

Six months ago, a senior architect at a bank I work with closed his laptop in a meeting, looked at me, and said the thing nobody on his team would say out

The era of the context-aware agent–business user is here. 🧠🤝 Ontologies and knowledge graphs aren’t handed down from a technical silo anymore. With OntoBricks 0.6.0, they’re created, managed, and consumed by business users and AI agents — in context: on the entity, the mapping, the graph node. Not in a side chat that loses the thread. 💬 Comment where the model lives ✅ Assign tasks to teammates 🤖 Let agents propose, map, and interpret — grounded in your data 🔍 Review every change — human or AI, always traceable Design together. Govern together. Query together. Same workspace. Same context. Same graph ... Everything stays in Databricks !!! OntoBricks 0.6.0 is out now 🚀 → https://lnkd.in/e8je4TGn #KnowledgeGraph #ContextAware #AIAgents #Databricks

Walk into any enterprise AI conversation today and you'll hear "ontology" everywhere. Then ask five people what an ontology actually is, and you'll get five different answers! This isn't a terminology problem.

Why every semantic layer eventually collapses under its own governance mass