GraphNews

Every enterprise racing to deploy AI agents is hitting the same wall: the models are brilliant, but they don't know what your business means by "customer," "exposure," or "active contract." They hallucinate not because they're broken, but because nothing in your architecture tells them what's true.

🧠 Prompt Engineering → 🗂️ Context Engineering → 🔁 Loop Engineering → 🕸️ Graph Engineering Four eras. 24 months. If your team is still optimizing for the first one, you're not behind ... you're solving last year's problem with this year's budget. On July 18, developer Peter Steinberger, the guy behind OpenClaw, asked a six-word question that reframed the whole debate: are we still talking loops, or did we shift to graphs? Half a million views in hours. Not because it was profound. Because a lot of engineering leaders were feeling it and hadn't said it out loud yet. I know that feeling. You finally get your arms around one operating model for AI-assisted development, and the ground moves again. If you're the one explaining this to your board next quarter, that whiplash is real. Here's the pattern underneath the buzzwords and why it matters for how you architect this work: 🔁 A loop is one agent, cycling through a task, deciding for itself what's next. Forgiving to set up. But a loop is a regulator, not a reference-setter it can hit a target you've already defined (tests passing, a clean build), but it can't decide what "correct" means. Point it at an ambiguous spec and it doesn't fail cleanly. It burns tokens guessing, in circles, until someone notices the invoice. 🕸️ A graph forces that decision up front. You map explicitly which agent owns which domain, how data hands off, what happens when a step fails. Harder to set up. Far more predictable at scale. What I'm seeing in production-minded teams: a split into two layers. 🏛️ A permanent org graph: named agents that own security, data, API contracts, frontend standards, and defend those boundaries continuously. ⚡ An ephemeral work graph: task nodes spun up for one feature or bug, that split, merge, and dissolve once validated, handing the result back to the permanent owners. If you're deciding how to structure this in your own org, three things I'd hold the line on: ✅ Keep shared state flat and strictly typed a bad output should route to a fix-it step, not corrupt everything downstream. ✅ Separate the model that generates code from the logic that decides what happens next. You do not need the same model you dev with to be your agent. ✅ Bound everything, no token maxing, iteration caps, token ceilings, a runtime limit, and a rule that pages a human the moment the state stops changing. That last one isn't optional. 📊 The FinOps Foundation's latest report found 98% of enterprises are now actively managing AI-related costs, up from 31% two years ago. That jump is what unbounded agent loops look like on a P&L. The technology under this shift is genuinely interesting. But the leadership question hasn't changed: where are the humans still setting the reference and where have you quietly let a system start guessing? #AI #EnterpriseArchitecture #DigitalTransformation #AgenticAI #CIO

Kurt Cagle & Chloe Shannon | The Ontologist

Constants, fluents, and the quiet failure of reification

Over the past several months, I have been building AICHAX — the trust layer for AI, where Answers are computed, not generated. LLMs hallucinate by design — it's built into the architecture. AICHAX takes the opposite path: a Graph Intelligence Engine where every answer is the deterministic result of traversing a real knowledge graph. Sourced. Auditable. Instant. And when the graph doesn't know — it says so, honestly. In under five minutes, watch it: 🔍 Verify a famous Einstein quote back to the original 1926 letter — source on screen 🧮 Compute math deterministically — steps shown, answered in milliseconds 🧬 Walk real relationship chains from Alan Turing to Geoffrey Hinton — live ⏳ Reason counterfactually over documented influence — evidence, not invented essays 🕸️ Flip any answer into a living, explorable graph — the evidence IS the interface 👪 Build sourced family trees, browse the painting canon, spiral ten thousand years of art into a galaxy 🧠 Ask your own mind — a Personal Wisdom graph that cites your own saved knowledge back to you Hallucinations end where structure begins. https://lnkd.in/gw9gAcjZ

I wrote an article, where I offered this definition of context: “Context is the situation or conditions that constrain both what information is relevant and how it should be interpreted to support effective decisions and actions.” In response, many people told me their knowledge graph provides their

Sign in or join now to see posts like this one and more.

𝙏𝙝𝙤𝙪𝙜𝙝𝙩 𝙛𝙤𝙧 𝙩𝙝𝙚 𝙙𝙖𝙮: There’s a new layer taking shape in AI and agentic AI solutions: the 𝗞𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲 𝗠𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁 𝗟𝗮𝘆𝗲𝗿 To me, 𝙩𝙝𝙞𝙨 𝙞𝙨 𝙩𝙝𝙚 𝙣𝙚𝙬 𝙄𝙣𝙛𝙤𝙧𝙢𝙖𝙩𝙞𝙤𝙣 𝘼𝙧𝙘𝙝𝙞𝙩𝙚𝙘𝙩𝙪𝙧𝙚 𝙛𝙤𝙧 𝙩𝙚𝙘𝙝𝙣𝙞𝙘𝙖𝙡 𝙙𝙤𝙘𝙪𝙢𝙚𝙣𝙩𝙖𝙩𝙞𝙤𝙣! It may seem relatively new, though some of us have spent the past several years warning that it was coming - in the form of taxonomies, ontologies, and knowledge graphs. The technical documentation community is in danger of giving away its future. This layer should belong to Information Developers and Information Architects, in partnership with engineering. It is not a side concern or an adjacent discipline. It is the next logical extension of information architecture - and one of the richest opportunities for new influence, new roles, and next-generation careers. Yet much of the profession remains focused almost exclusively on source content and source content structure. That work matters, but it is only half of the emerging information architecture. Organizing content without owning the knowledge layer, which is the extension of content structure, is what makes it discoverable, teachable, and usable is like designing a building and then handing over the floor plan to someone else to decide how people will move through it. If technical communicators do not take control of the knowledge management layer built on their content, developers will. And when that happens, the profession will not simply lose ownership of a system. It will surrender the very jobs, authority, and strategic relevance it has spent years claiming it deserves. | 49 comments on LinkedIn

The Enterprise Knowledge Layer (EKL) is a shared, governed substrate where an enterprise's knowledge lives. Learn more about it in our blog.

A library catalog is a deceptively hard graph problem. It looks simple: books, authors, subjects. But the moment you try to model derivations you're in deep waters. For instance, this translation was made from that critical edition, which itself corrects an earlier manuscript. That's before you touch provenance, uncertainty, or the fact that "Shakespeare" as an entity means something different in 1623 versus today. The Hamlet that existed as a quarto in 1603 is a different Instance than the First Folio version of 1623, which differs from the modern critical edition... The RDF bet: semantics first. BIBFRAME, the Library of Congress's replacement for MARC, is built on RDF. Its core move is to separate Work (the abstract creation) from Instance (a particular published form) from Item (the physical copy on the shelf). These aren't just categories, they're nodes in a graph, connected by typed predicates. RDF gives you something LPG cannot easily match: global identity. The cost is expressiveness at the edge level. RDF's triple model makes it verbose to attach metadata to relationships. When did this attribution change? Who contested it? RDF-star is addressing this, but it remains an afterthought on a model designed for facts, not so much claims. The LPG bet: richness at the edges. A labeled property graph lets you put properties directly on relationships. "Influenced by" can carry a weight, a date, a confidence score, a provenance note. Reification gymnastics is out 👌. For a museum modeling the relationship between an artist and a movement, or a library tracking the editorial history of an attribution, this is genuinely more natural. The tradeoff is the loss of global semantic grounding. LPG has no native concept of shared identity across systems. You can build it but it's not given to you by the model. Every institution ends up with its own node for Shakespeare, and reconciliation becomes a pipeline problem rather than an architectural guarantee. Cultural heritage institutions that care about interoperability (e.g. Europeana, the DPLA, national libraries) seem to have converged towards RDF and linked open data. The semantic web vision of a global cultural graph only works if nodes mean the same thing across systems. Visualization and dashboarding (BI) atop RDF is more complex than LPG. How this happens in practice I have not researched. Would enjoy input from the experts here 🤔 - BIFRAME implementation: https://lnkd.in/ebssxenu - Library workflows: https://lnkd.in/emy7hwJ6 - Singapore Library Blog: https://lnkd.in/ebbWvmQ2 #LibraryTech #KnowledgeGraphs #GLAM #RDF

As promised, here is a breakdown of what a foundational (or top-level) ontology needs to succeed in the future of Architecture and AI. To be clear, this isn't presented as the final, authoritative list, but rather a robust baseline designed to cover the major topics at their best. Because this is a massive topic, I am splitting this framework into two posts. Today, we look at the first four pillars. Because "requirement" is such an overloaded term in systems engineering, I’m structuring this using the SysFEAT methodology. Every point below is defined by a strict triad: the Job-to-be-done, the Capabilities required, and the overarching Principles that constrain the solution. Here is Part 1 of the 8-point master framework: 1. Foundational Syntax, Modularity & Conservative Extension 🎯 Job: Establish a robust, modular scaffolding that houses baseline vocabulary and allows non-destructive growth. 🛠️ Caps: A formal syntactic layer isolating structure from semantics, with absolute lexical scope and local encapsulation. ⚖️ Princ: Syntax precedes semantics. Additions must be strict conservative extensions with zero silent side-effects. 2. Spatiotemporal Existence & Identity 🎯 Job: Track entities across their entire physical and temporal lifecycle. 🛠️ Caps: Formal absolute/relative 4D indexing mechanisms backed by strict criteria of identity. ⚖️ Princ: Identity must be consistently verifiable (extensional or intensional) across an entity's entire footprint. 3. Semantically Exhaustive Relations & Reflexive Classification 🎯 Job: Provide comprehensive structural, existential, and taxonomic links. 🛠️ Caps: Axiomatized mereology, topology, directional holonymy/meronymy, and higher-order reflexive classification. ⚖️ Princ: Relations must capture fundamental asymmetries. Classification must support dynamic, cross-order aspectual roles without rigid stratification. 4. Logical Rigor, Computability & Proof 🎯 Job: Guarantee automated inference and machine-verifiable correctness. 🛠️ Caps: Built on formal, decidable logic (e.g., Higher-Order Logic) supporting strict computability and mathematical proofs. ⚖️ Princ: Formal rigor is absolute. Unverifiable constructs are strictly invalid. (Stay tuned for Part 2 newt week, where we will cover Granularity, Neutrality, Property Binding, and Metaphysical Transparency!)

I am pleased to share that a set of #Gartner vendor scorecards for popular data management platforms landed today. 𝑾𝒉𝒚 𝒅𝒊𝒅 𝒘𝒆 𝒖𝒏𝒅𝒆𝒓𝒕𝒂𝒌𝒆 𝒕𝒉𝒊𝒔 𝒆𝒗𝒂𝒍𝒖𝒂𝒕𝒊𝒐𝒏? Client demand. Almost a half of Gartner client interactions between January 2025 and April 2026, specifically within the “data management solutions” perennial priority, involved one or more mentions of #Microsoft, #Databricks, #Salesforce, #Snowflake, or #Palantir. Some of these conversations were direct comparisons of these data management platforms. D&A leaders regularly inquire about the effectiveness of these platforms for meeting use cases such as data foundation, semantic enrichment, domain enablement and agentic automation. 𝑾𝒉𝒂𝒕 𝒂𝒓𝒆 𝒕𝒉𝒆𝒔𝒆 𝒔𝒄𝒐𝒓𝒆𝒄𝒂𝒓𝒅𝒔 𝒇𝒐𝒓? These scorecards provide a holistic assessment of platform capabilities. D&A leaders can find answers to two key questions: 1. 𝐇𝐨𝐰 𝐦𝐚𝐭𝐮𝐫𝐞 𝐚𝐫𝐞 𝐭𝐡𝐞 𝐟𝐮𝐧𝐜𝐭𝐢𝐨𝐧𝐚𝐥 𝐜𝐚𝐩𝐚𝐛𝐢𝐥𝐢𝐭𝐢𝐞𝐬 𝐨𝐟 𝐭𝐡𝐞 𝐩𝐥𝐚𝐭𝐟𝐨𝐫𝐦?  This knowledge is essential for them to compensate for any specific platform weaknesses with targeted point solutions, ensuring that their data tech stack is comprehensive. 2. 𝐇𝐨𝐰 𝐞𝐟𝐟𝐞𝐜𝐭𝐢𝐯𝐞 𝐢𝐬 𝐭𝐡𝐞 𝐩𝐥𝐚𝐭𝐟𝐨𝐫𝐦 𝐢𝐧 𝐟𝐮𝐥𝐟𝐢𝐥𝐥𝐢𝐧𝐠 𝐬𝐩𝐞𝐜𝐢𝐟𝐢𝐜 𝐮𝐬𝐞 𝐜𝐚𝐬𝐞𝐬? This understanding is essential for executing their D&A strategy, that is, knowing what they can achieve with their technology investment. We have identified four use cases for the data management platforms: data foundation, semantic enrichment, domain enablement and agentic automation. My sincere appreciation to several colleagues who were instrumental in this research including Ehtisham Zaidi, Rita Sallam, Adam Ronthal, Masud Miraz, Aaron Rosenbaum, Nina Showell, Mark Beyer and Zain Khan. Its a must-read research for all Gartner clients https://lnkd.in/eYNGBtpn . #GartnerDA #datamanagementplatforms

This one is about sync'ing data with a knowledge graph, also known as change data capture (CDC). CDC events are graph mutations, yet nobody builds them that way. When Debezium tails your Postgres WAL and emits a row-level change event, it hands you something like this: { op: "u", before: { customer_id: 42, status: "prospect" }, after: { customer_id: 42, status: "client" } }... What actually happened in your knowledge graph? A node property changed. But more interestingly, probably an edge dissolved and another was created. The prospect relationship to your pipeline entity is gone and a client relationship exists now, with a timestamp, a source, and a provenance trail. The tools don't see it that way. Debezium, Airbyte, Estuary Flow etc. they're excellent at what they do but they model the world as rows before and rows after. The graph semantics is your problem. This impedance mismatch has real consequences. For example, entity resolution breaks at event granularity. A CDC event from a CRM says account_id: 7821 changed. Your KG has a node with IRI . The mapping between those two things is a whole other pipeline, one that has to run before, or alongside, the mutation. Most teams discover this the hard way. SAP and enterprise systems make it worse. Their change events are coarse-grained: a BAPI call, an IDoc, a business object delta. A single event can encode what is, in graph terms, a subgraph replacement: several nodes touched, several edges rewritten, some implied by absence. You have to reconstruct the mutation algebra from domain knowledge, not from the event structure. Kafka helps and hurts simultaneously. As a transport layer for CDC events it's superb, ordered, replayable, partitioned by entity. Still, a Kafka topic per table is not a topic per graph concept. The partitioning strategy that makes relational CDC fast is orthogonal to the entity-centric partitioning a KG pipeline wants. The right mental model: every CDC event is a patch on a graph. Not a row diff but a typed mutation on a typed graph.  If you build your ingestion layer thinking in those primitives, the downstream logic becomes dramatically simpler. The tooling will catch up I presume but right now, if you're building a live knowledge graph on top of CDC infrastructure, you're doing graph mutation modeling in your head. - Estuary Flow: https://lnkd.in/epkuF4HY - Airbyte: https://docs.airbyte.com - Debezium: https://debezium.io #KnowledgeGraphs #Debezium #ApacheKafka #ETL #GraphDatabase

By now most people in the software industry are very familiar with the concept of DevOps – normally understood as the combination of software development combined with operations to deliver software more efficiently and effectively, with an eye towards scalability as the system matures over time. It

We are living through another cycle of the same promise, wearing a new name. Every decade produces its golden hammer: UML would solve interoperability.

Following up on my Graphlit wind-down announcement, I’ve put together a non-confidential overview of the technology and IP available for acquisition. Graphlit is a production AI context and agent platform. It connects enterprise data, processes multimodal content, builds evidence-linked knowledge and context graphs, and makes that context available to applications and durable agents. The available portfolio includes: - 50+ source integrations and multimodal processing - Evidence-linked knowledge, context graph, search, and GraphRAG - Provider-neutral model operations across 25+ AI providers - Durable agents, hosted MCP, governed tools, skills, channels, and delivery actions - Four complete product applications - Public APIs, CLI, SDKs, infrastructure-as-code, and operating assets The technology and IP are available as an asset purchase, either as an integrated platform or around a focused set of assets. The attached document describes what was built and what can transfer. If it maps to something your company is building, contact me at [email protected].

How a useful architecture term became a vendor catch-all

A graph is only as trustworthy as the triples flowing into it. Most of them arrive with their meaning already stripped.

Thira raises $21M seed round led by Madrona to build an AI-powered agentic execution system for enterprise back-office automation.

How to Align Content with Knowledge Graph Entities Introduction to Knowledge Graph A Knowledge Graph (KG), also called an Entity Graph, is a structured database of real-world entities — people …

With the help of AI, a new open dataset turns global news into structured narratives of disasters that unfolded from 2014 to 2024, helping to better understand the dynamics of crises and human-environment interactions.

Posted in r/semanticweb by u/ScholarForeign7549 • 3 points and 4 comments

Rewriting Spark #GraphFrames in #Rust, or a billion-edges scale graph analytics using just a Laptop. I experimented with graph algorithms using #DataFusion as the core, achieving impressive results. For example, I can compute PageRank for a billion-edge graph using only 5 GB of memory. Or I can identify all the weakly connected components in a graph with two billion edges using only 10 GB of memory. Under the hood, Pregel ('think like a vertex') and the recent BSP/Map-Reduce papers are expressed as #DataFusion joins and aggregates. For comparison, igraph, which represents graphs as CSR matrices in memory, would require at least 16 GB of RAM (in reality, much more: 32 GB or even 64 GB for a more realistic estimate) to achieve the same. The trade-off is performance: if the graph fits in memory, the algorithms complete in 1-2 minutes. However, for out-of-core Pregel/BSP, it takes around 20–40 minutes (in the tight scenario). Previously, I thought that for billion-scale graph analytics, you needed Apache #Spark + #GraphFrames. Now, however, I think that a laptop with a large SSD is sufficient. Not vibe-coded: I'm learning Rust/DataFusion using this project, so no reasons to do "Claude write this make no mistakes".

Automatic ontology development isn't a feature you build. It's an emergent capability of the neurocognitive stack — and that changes everything about how enterprise intelligence gets made.

Core-based hierarchies improve GraphRAG by replacing unstable, stochastic clustering methods with deterministic k-core decomposition. This density-aware structure identifies cohesive subgraphs, creating reproducible, size-bounded communities that improve global sensemaking while reducing token usage by up to 40%.Why k-Core Decomposition?Traditional GraphRAG pipelines rely on Leiden or Louvain clustering to map community hierarchies. However, on sparse networks, these algorithms produce exponentially many near-optimal partitions, making them non-reproducible. The k-core approach resolves this by organizing graphs into nested layers based on network density.Determinism: The same input graph always yields identical communities, ensuring reliable and stable summarization.Hierarchy: Each node receives a core number (k), representing the largest subgraph where all nodes have at least k neighbors, organically separating peripheral ideas from central cores.How it WorksDecomposition: The system processes knowledge graphs in linear O(|E|) time to peel away the graph by core numbers.Heuristics: Lightweight heuristics split these layers into size-bounded, connectivity-preserving community structures.Sampling & Summarization: The framework recursively summarizes these structurally coherent communities for downstream retrieval, incorporating a token-budget-aware sampling strategy to minimize LLM inference costs

🟢 Yes - this is how we use AI agents to connect Ontology + LLMs (inspired by Tony Seale and his Knowledge Graph Guys blog) in our data discovery engagements. In data modernization program, every data strategist has to build context from the existing data landscape: understand each source system, reconcile conflicts, identify gaps, map use cases, take action, and eventually deliver capabilities in a modern data product architecture. This takes months. If you've done the job, you know the pain: navigating tribal knowledge in outdated documents, chasing data owners no one knows them, and the systems no one fully understands anymore. A native AI approach allows use to use AI agents to build context ontologically per source, then surface where to reconcile. That's a huge head start for building a curated view of the landscape. A quick example. From sample data a strategist uploads, the AI generates one ontology per system — Billing and Support. Ontology 1 : Billing (source 1) # Billing system ontology Account -Subscribes to- Plan Account -Billed by- Invoice Account -Has status- BillingStatus Account -Has email- EmailAddress Ontology 2 : Support (source 2) # Support system ontology Customer -Raises- Ticket Ticket -Assigned to- Agent Ticket -Has status- TicketStatus Customer -Has email- EmailAddress A reconciliation assistance Agent flags 3 places to reconcile: 1️⃣ Overlap — EmailAddress appears in both ontologies 2️⃣ Identity — Account and Customer may be the same real-world entity 3️⃣ Semantic collision — billingStatus and ticketStatus may both be a Status While the agent does the heavy lifting, our strategist verifies it in a real business context. Months of discovery compressed into a reviewable first draft. #agenti-ai #ontology #knowledge-graph | 36 comments on LinkedIn