
Connecting Data, People & Ideas since 2016. Using relationships, meaning, context in Data to achieve great things #KnowledgeGraph #GraphDB #AI #SemTech
The World
Joined April 2016
- Tweets6.4K
- Following2.5K
- Followers7K
- Likes2.4K
Connected Data retweeted
Replying to @Connected_Data
The key perspective I leaned at CDL:
The old ontology was built to make the world intelligible to machines.
The new one makes collective intelligence intelligible, and governable, to people.
Its purpose is not to hold intelligent systems back. It is to lay the common ground on which different kinds of intelligence can work together.
For enterprise architects, that is now the work. Design the loops, the authority, and the commitments.
Who holds the loop? Whoever holds the shared meaning, the legitimate authority, and the record of what was agreed.
The lasting value of an ontology is not how much intelligence it adds to any one agent. It is how much trustworthy collective agency it makes possible.
intuitionmachine.com/explain…
2
97
Connected Data retweeted
The Neo4j Ontology Graph Specification: A pragmatic, open, AI-first approach
An open-source specification for representing domain knowledge in a machine-readable form, enabling interoperability and automation across data, applications and AI systems.
Three design principles:
- Pragmatic: entities, relationships, properties and business meaning, described in a form that fits how teams develop, integrate and operate applications.
- Interoperable: documented mappings to selected RDFS and SHACL constructs, a reference field linking every element to external standard terms, and added constructs for a wider range of application scenarios.
- AI-first: a schema tells an agent what exists, not what it means. Descriptions and aliases tell it that “Account” can be a bank account or a payment account, and that an IBAN identifies it.
One ontology, many uses.
The same specification can be enforced by the database as constraints, drive ontology-based logic to derive or enrich data, or give applications and agents the context to interpret information. It spans knowledge graph development, GraphRAG, data validation and AI-powered applications.
What’s included:
- Nodes and relationships with stable IDs, labels, descriptions and aliases
- Properties across the full Neo4j type system, including temporal, spatial and vector types
- Cardinality and constraints (existence, uniqueness, key, property type)
- Named extensions for indexes, display hints and data-source mappings
- A single YAML or JSON document, validated against a versioned JSON Schema, with SDKs for JVM, JavaScript and Go
- Apache 2.0 licence
Similar needs show up in Palantir Foundry, Databricks Genie Ontology and Microsoft Fabric IQ: explicit, machine-readable domain knowledge that data systems and AI can both use.
By Jesús Barrasa and Oskar Hane
The Neo4j Ontology Graph Specification: A pragmatic, open, AI-first approach neo4j.com/blog/developer/the…
Neo4j Ontology Graph Specification neo4j.com/docs/ontology-grap…
#Ontology #GraphRAG #Neo4j #AIAgents #OpenSource
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you’d like to be featured
Comment link: neo4j.com/blog/developer/the…
Connected Data retweeted
Knowledge Graph Lakehouse: A Cloud-Native Architecture for Managing Enterprise Knowledge Graphs at Scale
What if the knowledge graph were built only when a question asks for it?
Enterprise knowledge graphs model connected domains well. At scale, volume, velocity and variety turn a single monolithic graph into something slow to ingest, hard to govern and often out of date.
The Knowledge Graph Lakehouse inverts the order:
Source documents land unchanged in a data lake
A contextual index records which contexts each document is valid for (time, location, topic)
Application-specific contextualized KGs are constructed on demand, only for the contexts a query names
Interpretation is deferred to query time. What the system holds durably is the documents and the index.
The design is grounded in KG-OLAP: contexts are cube cells, slice, dice and roll-up select and merge them, and knowledge propagates from covering contexts. Results are delivered as RDF quads, a labeled property graph or a GraphFrame.
🌍 Environmental data shows what this looks like in practice
Regulated facilities change ID numbers, sit under parent corporations that acquire and spin off sites, and trade waste with sister facilities across overlapping jurisdictions. The records are spread over EPA systems such as RCRAInfo, ECHO and TRI, plus SEC filings.
One lakehouse, three graphs:
PFAS in a watershed: facilities, permits, pollutants, receiving waters, corporate parents
Enforcement: violations, inspections, consent decrees, responsible legal entities
Waste tracking: generators, transporters, manifest chains
The lakehouse stays authoritative. The graph becomes a disposable perspective.
📊 Evaluation (air traffic management):
Corpus grew from 28,590 to 324,456 documents; construction time for a fixed scope stayed near 2 seconds
The index stayed around 1% of corpus size
A new batch of 255 documents became queryable in about 18 seconds, against a 55-minute rebuild of a materialized cube
Peak memory: about 1.4 GB on demand, 46 GB for the materialized build
The architecture suits workloads whose scope is declared before any data is touched. Arbitrary queries over a standing graph remain better served by a materialized store.
By B. Ahmad, C. G. Schuetz and L. Bozzato. Example by David G. Smith.
davidgsmith.net/thoughts/why…
#DataLakehouse #CloudNative #KGOLAP #DataArchitecture #ContextualKnowledgeGraphs
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you’d like to be featured
Connected Data retweeted
Which Local Model Should Build Your Knowledge Graph? A Reproducible Leaderboard
A local model that chats well can still build a messy knowledge graph.
Most local-model leaderboards score chat. A knowledge graph gives a model a different job first: read a passage, name the entities and relationships in a strict format, and point to the sentence that proves each one. Only later does it answer a question from what was extracted, without inventing anything.
Those two jobs rank models differently. This leaderboard scores 22 local Ollama models on both, using pass/fail checks and no judge model. 🔎
What is measured:
- Extraction: 65 isolated probes, plus 39 spliced into real chunks of War and Peace, covering output format, evidence, entity and relationship discipline
- Chat: identical questions on Book One, answered from the same reference graph and retrieved context. An answer passes only if it names what was asked, nothing the context lacks, and declines when the book is silent
- Overall: 0.6 extraction and 0.4 chat, with in-chunks extraction counted twice
What the board shows:
- The chat column is bunched. The extraction column spreads wide
- Size is a weak predictor. Gemma 4 12B sits among models needing far more GPU memory, while several 30B-class models rank low as their in-chunks extraction falls apart
- Gemma 4 31B leads on Overall and also built the reference graph behind the chat column
- Every score carries a 90% interval from 2,000 resamples, and neighbouring rows are often ties
- Flags explain low scores: answers cut off at the output limit, runaway repetition, or reasoning despite thinking being switched off
- Models without Ollama tool calling can be scored but cannot serve as the chat model in the app
The board is reproducible with a handful of CLI commands (pipx install chaoscypher-cli, then run the probes and chat-probes benchmarks). Exact numbers shift with Ollama versions and quantizations. The clusters should hold.
The scores reflect each model together with ChaosCypher’s prompts and pipeline, on one novel for the chat column. The result is a basis for shortlisting models, not for settling on one.
By Denis MacPherson
dev.to/chaoscypherinc/which-…
#GraphRAG #Ollama #LocalLLM #SelfHosted #Benchmarks
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you’d like to be featured
Connected Data retweeted
🦋 Catch the Butterfly: A Series A, and the Graph Engines continent behind it
Why is a sales target being missed?
An agent rules out region, sales team, pricing and competitors, one by one. What remains: slipped deals that share products with long delivery delays.
Deals → products → components → a supplier behind on one part.
Three hops from the original data. Nowhere a person would think to start.
That investigation anchors PuppyGraph’s $10M Series A (led by Particle Future, with defy.vc, $15M raised in total).
The ideas underneath travel beyond one company:
- Copilots answer questions a person already framed. Agents plan, query, read the result, and let it choose the next query.
- Text-to-SQL works when relationships are known. Across thousands of tables, two integer ID columns (student, employee) join cleanly and mean nothing.
- A failed query is visible. A successful query on the wrong relationship is not, and the next question inherits it.
- An ontology in the query path can reject undefined entities and return structured feedback. People approve relationships, not every question.
- Testing many hypotheses is query-hungry, so latency caps what an agent can explore. Discovery needs broad access, so permissions have to hold at each traversal step.
The announcement also describes a category: an engine running multi-hop traversals over existing databases, warehouses and lakes, with no separate graph copy. State of the Graph defines Graph Engines as the layer that computes over existing systems, with no primary graph storage of their own.
In the November v2.0 map (212 listings, 172 products, 146 vendors), the Graph Engines continent holds 7. All query data where it lives. None is a system of record. Four run on Snowflake or cloud warehouses. Zero-ETL is one of two forces reshaping the market, beside agentic AI and GraphRAG.
Catch the Butterfly: PuppyGraph Raises $10M Series A to Build the Data Engine for AI Agents puppygraph.com/blog/series-a
Surveying the Graph Engines Terrain stateofthegraph.com/2026/05/…
7 Continents, 5 Shifts: The Graph Technology Map, Redrawn stateofthegraph.com/2026/11/…
#GraphEngines #AIAgents #ZeroETL #Ontology #Lakehouse
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you’d like to be featured
Connected Data retweeted
Graphs can help solve the AI agent memory problem
Agents have a memory problem, Dave Bechberger notes: close the session, and everything they learned is gone. A useful long-term memory layer has to satisfy four properties: persistence, relevance retrieval, relational structure, and temporal validity.
Vector stores nail the first two. But relationships and time are second-class citizens in a flat index; there’s no native way to ask “what led to what” or “what did we believe last month.” That’s the gap graphs close.
Every edge should carry two independent clocks: valid time (when a fact was true in the world) and transaction time (when the system learned it). Nothing gets erased. Old edges get marked superseded as new evidence arrives, which makes “what did we believe last quarter” a query instead of a mystery.
Left unmanaged, though, a memory graph rots: duplicate nodes, stale edges, quiet contradictions. Entity resolution, contradiction handling, decay, and compaction are what keep it usable rather than a junk drawer.
Worth noting: this isn’t free. Construction cost, schema drift, and cases where a flat vector store is simply enough are real tradeoffs.
William Lyon explores types of agent memory, and Animesh Kumar explores the first wave of agent memory systems – defining what memory is, exploring history and different implementations, and pointing out six cracks.
As both Kumar and Bechberger point out, evaluation of long-term memory systems remains unsolved. No clean benchmark exists yet for multi-hop accuracy or temporal correctness.
--
📩 Excerpt from The Year of the Graph Autumn 2026 newsletter
Read "# Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI" with more sections, references and attribution here 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Connected Data retweeted
Maximum Relevance, Minimum Context: Cutting Through the AI Graph Stack
Semantic layer, context graph, ontology, GraphRAG, decision traces. The terms overlap, and the role of each piece is rarely stated.
But which gap does each piece fills? To decipher this, let's follow one customer, Ana, asking for one refund on a broken burr grinder. Adding one layer at a time:
→ Vectors alone answer confidently, about the wrong Ana.
→ An ontology and a knowledge graph find the right customer and the right order (#1042, delivered Sep 3). The agent still sees every customer and every past state.
→ A Context Graph scopes what the agent sees. Policies decide whether it may act.
→ Memory records the decision, so a repeat request gets caught and the first one can be explained.
The structural point:
- The ontology and knowledge graph are stored, governed data
- The Context Graph and Policies are views, recomputed on each request
- Memory is the only new data in the stack
Two questions to ask of any component: what breaks if it is removed, and is it a view or a store?
The post also covers bitemporal facts (valid time and transaction time) and places GraphRAG as a retrieval pattern over the Knowledge Layer rather than a layer of its own. It offers a quick test for when a request needs no graph at all (count the hops, rules and time questions), and four measures to take before expanding.
Every buzzword lands on a single diagram, and five questions at the end sum up the differences.
By David Bechberger
medium.com/@bechbd/maximum-r…
#GraphRAG #Ontology #ContextEngineering #AgenticAI #SemanticLayer
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you’d like to be featured
Connected Data retweeted
Graph-Mediated LLM Systems in the Agentic Era: correct retrieval does not ensure correct action
A facility changes operator from O1 to O2. Memory records O2 as current and keeps O1 for history. A saved notification plan still names O1.
Retrieval succeeds. Message delivery succeeds. The action fails.
That gap anchors a new survey on graph-mediated LLM systems: agents that use graphs for reasoning, knowledge, memory, execution and communication.
In agentic systems, one step feeds the next. A retrieved fact becomes a tool argument. A stored memory shapes a later plan. A correction has to reach another agent before it is useful. A gain on a local metric does not always carry downstream.
The survey classifies each graph operation along two axes:
- Role: reasoning objects, knowledge & evidence, retrieval & memory, execution programs, coordination & communication
- Locus: internal LLM inference, graph-conditioned interfaces, external traversal and execution, agentic orchestration
One system can hold several role-locus pairs, which makes it possible to ask what an operation hands to the next step.
🔍 The evidence, with test conditions kept attached:
- GNN-RAG: sparsifying the graph improved node prediction but lowered answering, because disconnected support prevented path extraction
- Dialogue memory: graph vs flat ordering reversed depending on whether original sessions or derived keys were returned
- GCR: removing the path constraint sharply lowered path conformance while answer accuracy changed little
- Communication: sparse routes reduced the influence of both harmful and useful information
For evaluation, the survey proposes:
- Whole-pipeline comparisons, or fixed upstream inputs
- Process diagnostics: what was available, selected, stored and delivered
- Full cost reporting: construction, updates, retries and failed runs
Open challenges: adaptive computation and stopping, memory consistency during updates, and recovery when dependency records are incomplete.
The question running through the survey: how does a graph operation affect the work that follows, and can a correction travel that far?
By Haihui Liu, Yang Chen, Zice Qiu, Yun Zhang, Jialun Zhong, Wenhua Wang, Yanzeng Li and Tian Wang
arxiv.org/abs/2611.05953v1
#AgenticAI #LLMs #GraphRAG #AgentMemory #MultiAgentSystems
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you’d like to be featured
Connected Data retweeted
GraphRAG needs great graph visualization
GraphRAG can ground AI-generated answers in connected data. But presenting those results clearly is another challenge.
Graph visualization helps users understand how an answer was reached, spot anomalies in the underlying data and make sense of complex paths and relationships. And when the first answer raises another question, an interactive visualization gives users a way to keep exploring.
This free guide by Cambridge Intelligence covers the foundations of effective graph visualization, from data modelling and layouts to reducing visual noise and choosing the right technology.
Download the ultimate guide to graph visualization 👇
go.linkeddataorchestration.c…
Cambridge Intelligence - helping bring Year of the Graph to life
#visualization #datamodelling #GraphRAG #AI #connecteddata
Connected Data retweeted
Knowledge Graphs beyond the hype cycle: From the peak of inflated expectations to the plateau of productivity
In 2020, Gartner introduced knowledge graphs in its Hype Cycle for Artificial Intelligence, at the Peak of Inflated Expectations.
In the 2026 Hype Cycle for Artificial Intelligence, Gartner has placed knowledge graphs in the Plateau of Productivity.
For a technology that was born in the early 2000's, that would mean having spent 20 years at the Innovation Trigger stage.
But then again, Gartner's Hype Cycle for Artificial Intelligence only started in 2020.
In reality, the foundations and principles for building Knowledge Graphs have not changed much since their inception in the early 2000's.
So in a way, Gartner did the right thing by placing Knowledge Graphs at Peak of Inflated Expectations in 2020.
Gartner introduced GenAI in their first Hype Cycle for Artificial Intelligence in 2020. GenAI's boom in 2023 brought LLMs, hallucinations, uncontrollable token spend, RAG, and GraphRAG to the world.
In reality, it's GenAI that pushed Knowledge Graphs to the Peak of Inflated Expectations circa 2024.
As Knowledge Graphs became mainstream, people and vendors started using the term in many overlapping and inconsistent ways, and everyone now claimed to have one.
If Gartner places Knowledge Graphs at the Plateau of Productivity today, that probably says more about market and perception maturity than it does about the technology itself.
That's not to say that there hasn't been any evolution in areas such as storage layer capabilities and access layers, data modeling constructs, or tooling - there clearly has been.
The next frontier for the hype cycle is already being claimed: meaning and context, powered by ontology.
In reality, the history of Ontology in computer science goes hand in hand with Knowledge Graphs, and again, the foundations and principles for building them have not changed much since their inception in the early 2000's.
We are already seeing the same hype cycle at play: mainstream adoption, variation, redefinition.
The takeaway: adoption and hype cycles are great. What's even better is grounding adoption on first principles, established methodologies and practices that span decades.
References:
Knowledge graph evolution: Platforms that speak your language zdnet.com/article/knowledge-…
Knowledge Graph Enlightenment, AI and RAG yearofthegraph.xyz/newslette…
The Ontology issue: From knowledge to graphs and back again yearofthegraph.xyz/newslette…
Layers of Meaning: Context Graphs, Graph Memory, and Ontologies for AI yearofthegraph.xyz/newslette…
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI yearofthegraph.xyz/newslette…
AI’s trust ceiling is a problem of meaning. Connected Data London has spent the last ten years defining it linkedin.com/pulse/ais-trust…
Gartner Hype Cycle for Artificial Intelligence, 2026 gartner.com/en/documents/831…
--
💬 ‘A great newsletter’ - Claudia Remlinger, former Sr. Marketing Director, Neo4j.
Join readers from Amazon, Capgemini, Michelin, Neo4j & more
Subscribe to the Year of the Graph newsletter for quarterly updates and insights on all things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech 👇
yearofthegraph.xyz/newslette…
Connected Data retweeted
Graph engineering for AI agents
The way people work with coding agents keeps getting named one level up, André Lindenberg points out. First prompt engineering: phrase the request well. Then context engineering: control what the model sees. Then loop engineering: stop prompting the agent and build the system that prompts it – cf. Gartner’s learning loops.
Then the next rung got its name. Peter Steinberger, one of loop engineering’s loudest early voices, asked whether we are still talking about loops or have already shifted to graphs. The single loop is the atom of getting better, Carlos E. Perez writes. Choose something to control, set a reference, measure the gap, act to close it, repeat.
It’s simple, cheap, and it works. But the single loop fails in four specific, structural ways: Goodhart’s law, blindness upward, conflict, and measurement decay.
The emerging answer is a graph of loops: networks of improvement cycles that watch, feed, constrain, and correct one another. A knowledge graph is about how information connects, while an agent graph is about how work moves through a system, Nhu Hoang adds.
A loop is one agent, cycling through a task, deciding for itself what’s next. A loop 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 burns tokens guessing in circles.
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, but more predictable at scale. Nick Perry observes that production-minded teams split that 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.
--
📩 Excerpt from The Year of the Graph Autumn 2026 newsletter
Read "# Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI" with more sections, references and attribution here 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Connected Data retweeted
Stop Mixing RAG, Knowledge Graphs, Semantic Layers and Agents
Retrieval is not understanding. Neither is a nice diagram.
Picture the AI kick-off whiteboard: an LLM in the middle, surrounded by RAG, Knowledge Graph, Vector DB, Semantic Layer, Agents and a cloud labelled “Enterprise Knowledge”. Every box points to the LLM, and the LLM points back. It looks impressive. It says nothing about what happens when a user asks a question.
Part 3a of the series “Stop Mixing Things: Understanding the Layers Beneath AI” moves from terminology to runtime. Same layers, five verbs:
Data Catalog → Find. Where is the information, and may it be used? Ownership, sensitivity labels and lineage become routing information.
RAG → Retrieve. Which text is relevant? It does not count, does not join, and does not know what is current without metadata.
Semantic Layer → Contextualize. What does the business mean by “revenue”? The model no longer improvises the definition.
Knowledge Graph → Connect. How are things related across hops and domains? It also resolves “PaySvc” and “billing-api-v2” as one entity.
Agent → Act. What happens next, and through which tool? This needs memory, permissions that follow the user, tool contracts, a notion of time and traceability.
Most whiteboard disasters come from expecting one of these verbs to do the other four.
The illustration is an architecture advisory assistant. Early versions returned fluent, well-cited answers, sometimes built from a superseded guideline that happened to have nicer wording. The text matched the question. Nothing told the system whether it was current, authoritative or applicable.
The improvement did not come from a better model. It came from chunk metadata (source, owner, last review, validity) and from the boring layers behind it.
Runtime failure modes worth recognizing 👇
“Just put RAG over everything”
“The LLM will figure out the joins”
“We’ll build a knowledge graph for the AI”
“Our agent is a chatbot with tools” (a car is a sofa with wheels)
Not every system needs all five layers. Guidelines and how-tos: start with RAG over curated documents with solid metadata. Numbers: start with the semantic layer. Relationships across many systems: that is where the graph pays off.
By Thilo Hermann
blog.gopenai.com/stop-mixing…
#RAG #SemanticLayer #AgenticAI #Ontology #GraphRAG
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you’d like to be featured
Connected Data retweeted
Trillion-edge graphs and custom TPU kernels, built in days by Gemini 4 Argon agents
A legend for the map 🗺️
• Gemini 4 Argon: Google's frontier model. 1M-token context, tunable reasoning, native sub-agents.
• Antigravity and Teamwork: Antigravity is Google's agent-first development platform. Teamwork is its multi-agent mode, where agents propose, critique and refine each other's work for hours or days.
• Distributed Graph Flow: the graph mining and graph learning stack from the team behind TensorFlow GNN.
• FarArray: a PGAS (Partitioned Global Address Space), so a cluster's RAM reads as one flat array. It runs over RDMA: network cards read, write and run atomics in remote memory, bypassing the OS kernel and the remote CPU.
• Sparse GNN kernels: message passing is a sparse matrix product, awkward on TPUs built for dense ones. Pallas is JAX's language for hand-written TPU kernels. HBM is the chip's main memory. O(N) means memory grows with nodes, not edges.
• Connected components sort every node into the island it can reach. InstantEmbedding turns Personalized PageRank into one vector per node.
The expedition
An estimated one-year distributed systems roadmap ran as a 5-hour gated sprint, with an auditor agent rejecting mocks.
• Connected components on 1.14 trillion edges, using 148 GB of pinned DRAM in total
• Web graphs of 113B to 129B edges: 60x and 90x the throughput, 40x and 180x faster than TCP key-value baselines
• InstantEmbedding: 11 to 27x faster, up to 56x less cumulative memory
The Pallas kernels on TPU v6e:
• HBM at 21M edges: 111.5 MiB flat vs 20.2 GiB in native JAX (up to 185x less)
• Forward and backward GNN passes 8 to 15x faster, with exact numerical parity
Humans set interfaces, memory layouts and acceptance tests. Agents implemented, debugged and tuned.
Where the map leads
Components at this scale serve:
• Web graphs: ranking and spam-network research
• Entity resolution: matched record pairs merge into one entity
• Fraud rings: seemingly independent accounts link up through shared devices and cards
GNNs already power Google Maps ETAs and Pinterest recommendations (3B nodes, 18B edges). GraphCast forecasts 10 days of weather in under a minute on one TPU v4. A Google graph foundation model gained 3 to 40x average precision on internal tasks like ads spam.
Flat memory per layer puts more graph on each chip.
By The Antigravity & Google Research Team
antigravity.google/blog/gemi…
#GraphMining #GNN #TPU #DistributedSystems #AgenticAI
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you'd like to be featured
Connected Data retweeted
Query More. Wait Less. TentrisDB is a high-performance, disk-based RDF graph database
Tentris enables organizations to unlock the full value of their knowledge graphs by making large-scale graph analytics economically viable.
Its novel query engine and compressed index structure efficiently execute complex analytical workloads while reducing memory requirements and infrastructure costs.
This enables applications ranging from Enterprise AI and GraphRAG to digital twins, life sciences, and supply chain analytics.
By combining performance, scalability, and efficiency, Tentris transforms knowledge graphs from static repositories into real-time analytical assets, helping enterprises accelerate AI initiatives and build applications on connected, trustworthy knowledge.
#EnterpriseAI #GraphRAG #digitaltwins #analytics #knowledgegraphs
Tentris - helping bring Year of the Graph to life 👇
go.linkeddataorchestration.c…
Connected Data retweeted
Multi-hop traversal on Lance, without a join per hop 🧭
In lance-graph, every relationship hop is a join between edge and node tables. A multi-hop query repeats that join at each step, building a hash table and materializing every intermediate path each time.
lance-csr takes another route. Neighbours are stored together in a compressed sparse row (CSR) adjacency index, so a hop becomes an array lookup instead of a join. Hops the CSR can’t express fall back to a join.
HDC Labs now maintain the project as an Apache 2 fork of lance-graph, written in Rust on Apache DataFusion, with Python bindings. It is a research test bed asking how far DataFusion can be pushed for multi-hop graph traversal over a columnar format.
How it runs
- Multimodal data and graph stay on disk in LanceDB
- Tables are read lazily or held in memory
- Queries see a consistent snapshot, and refresh() picks up committed changes
- The CSR updates incrementally, with a full rebuild when needed
What the fork adds
- Cypher broad enough for all 14 GDC (formerly LDBC) Interactive complex queries, including OPTIONAL MATCH, EXISTS and shortestPath
- Planning that starts each pattern at its most selective node
- Correctness fixes to inherited behavior, each backed by a regression test
- Prebuilt Python wheels for Apple Silicon macOS and x86-64 Linux
In the project’s own unaudited benchmarks (SF1, Apple M5), the 14 queries run 3.9× faster than Neo4j with tables in memory and 1.8× faster with Lance on disk (geometric mean).
The scope is deliberate: lightweight, embeddable, single machine, Lance only. Other Rust projects cover fast graph traversal, and distributed execution is out of scope here.
Credit goes to Beinan Wang, Chunxu Tang and the lance-graph contributors for the Cypher parser, semantic analysis, DataFusion planner and Python bindings, and to the DataFusion community. Contributions from people and their coding agents are welcome. ⭐
By HDC Labs
github.com/hyperdimensionalc…
#Cypher #DataFusion #LanceDB #Rust #OpenSource #Python #DataScience
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you’d like to be featured
Connected Data retweeted
Ontology helps AI agents go from retrieval to execution
The difficult part for enterprise agents is rarely calling an API, Yuan Gao notes. The difficult part is deciding whether an action is allowed, executing it without creating an ambiguous side effect, and proving what happened afterward.
We are moving from “can the agent retrieve and explain the right information?” to “can the agent make a governed decision and complete the work reliably?”.
Retrieval can surface every document containing the word order. It can’t guarantee the agent picked the right business object.
An ontology makes those distinctions explicit: the objects in the enterprise, their states, their relationships, the authoritative source for each definition, and which concepts can’t be substituted for one another.
But ontology’s role doesn’t stop at definitions. It participates across five stages of an agent’s lifecycle: understanding the enterprise, finding the right data, governing action, planning workflows, and verifying execution.
Emmanuel Klinger argues for a more pragmatic ontology for AI agents, built on six principles:
Object-relational, human explorable, virtualized, natural language semantics, domain-driven, use-case driven and additive. A bit of controlled imperfection may drive adoption, trading some rigor for usability, speed, and operational fit.
A graph can be the right place to model and govern how things relate, especially an ontology, which is small, slow-changing, and genuinely graph-shaped.
But where context lives and what the agent queries at runtime are separate calls, Andrew Lentz notes. Graphs can help by selecting context, not necessarily by making the model traverse it.
--
📩 Excerpt from The Year of the Graph Autumn 2026 newsletter
Read "# Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI" with more sections, references and attribution here 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Connected Data retweeted
Mind the Memory Gap: Graph Memory for Agentic AI 🚆
Every new session, an agent steps onto a new train. The doors close, and the decisions, constraints and precedents from the last journey stay behind.
The article frames this as an architectural gap, not a tuning problem. Better prompts and bigger context windows don’t address it.
For credit decisions, fraud flags and compliance actions, the cost is an auditable chain of decisions, which a transcript cannot supply. Each session completed without a persistent record is one more decision that cannot be defended later.
The proposed layer is graph memory: a persistent, queryable decision-trace record that survives session boundaries, delivered via a context graph architecture.
What defines it:
Stored: the decision, its reasoning path, the policy version in force, the precedent drawn on and the outcome, rather than the conversation
Connected: as a graph, so decisions link to entities, policies and similar prior decisions
Retrieved: every claim traces to the specific node that grounds it
Two ways to build it wrong:
Treating memory as a static snapshot of a moving world
Re-deriving everything when something shifts, when structure allows a single outdated node to be flagged and repaired
Structure makes memory auditable, and it makes memory correctable.
The worked example: a lending agent weighs a credit line increase after a utilization spike. The graph surfaces a precedent from two years earlier, an inventory purchase approved through a documented human override. The agent applies the same reasoning and records exactly what it drew on.
Six months later, a regulator questions apparent disparate treatment between two customers. The bank retrieves the decision, policy version, precedent and override, and shows the cases were not comparable.
The test for when it is needed has two parts. The decision must need to survive scrutiny later, and the domain must move fast enough that stale memory is actively wrong. Insurance claims denials, manufacturing safety overrides and healthcare escalations follow the same logic.
The market signal: per State of the Graph, 86.5% of 37 core runtime knowledge graph platforms are now GenAI-native or RAG-ready, and GraphRAG and agent memory listings grew nearly 78% in three months.
The gap was never whether the agent got the decision right in the moment. It is whether the organization can prove, months later, that it did.
By Maya Natarajan
mayanatarajan.substack.com/p…
#AgenticAI #GraphMemory #ContextGraph #AIGovernance #AIAgents
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you’d like to be featured
Connected Data retweeted
Context = Knowledge + Expertise + Norms
Context = Knowledge + Expertise + Norms, Prukalpa argues. The enterprise context layer turns all three into machine-usable context for agents. It has two halves.
A core substrate with three tightly integrated parts: AI-ready data and a knowledge graph, semantics and ontology (the shared meaning layer), and skills (reusable, versionable, testable units of procedural knowledge).
Plus five capabilities that run on top: context mining, a development lifecycle for context itself, compounding learning loops, activation and retrieval across many interfaces, and governance and observability.
Florence Benezit notes the data architectures agents access are excellent at storing what’s true right now, but they were not designed to keep how it got that way. The fix she proposes is similar – three layers stacked together: knowledge graphs, ontologies, and context graphs.
When agents become the primary consumers of your data, your data architecture becomes your AI architecture, Pramod Sadalage and Prem Chandrasekaran add. To make data ready for agentic AI, they introduce the AI-ready data stack.
Data contracts and quality to make data trusted. Then traceability and governance to records why an agent acted and bounds what it can reach, making data traceable and governed. The context layer encodes what metrics and entities mean, making data contextual.
The context layer includes a domain model of entities and relationships, a semantic model of metrics compiled to SQL against the analytical store, and a capability model of guarded reads and actions against live systems, with provenance signals across all three.
Building on this, agents can query live systems and write back, making data operational.
--
📩 Excerpt from The Year of the Graph Autumn 2026 newsletter
Read "# Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI" with more sections, references and attribution here 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Connected Data retweeted
Context Is King: Knowledge Graph Identifiers and Ontology as the Shared Layer Beneath Every Agent
Ask three agents for the on-time delivery rate and get three answers. One reads a BI model, one its own prompt, one a vendor application. Each definition is reasonable alone. Together they form a hydra: fix one inconsistency and two more grow back in the next agent.
The terms are often used interchangeably. They are different things, and confusing them leads teams to build the wrong one.
* Context engineering is a chef choosing ingredients for one dish.
Scope: a single agent and its prompt
* Context layer is the pantry, labelled and stocked.
Scope: the shared definitions of meaning and identity
Five shared elements, with the ontology as the spine. Every other component either references it or is typed by it
* Context fabric is the labelling standard and inventory system.
Scope: any chef in any kitchen finds the same ingredient by the same name
Federated ownership of context, with centralised meaning and access
Not a product. Fix the shared contracts and the tools underneath can change without breaking agents
* Where knowledge graphs come in:
The ontology defines what “delivery risk” or “strategic supplier” means, once
Every entity gets one enterprise IRI. Source-system IDs from the ERP, the procurement system and contract PDFs map to it through a key crosswalk
That is linked data principles applied directly: globally unique identifiers, shared by every source, that embed no vendor or system
The shared IRI, not a shared store, joins live status, lakehouse history and a contract clause into one answer
When a source system is replaced, only the mappings are re-pointed. Agents, prompts and dashboards stay as they are
The same logic reaches the edges:
NER label sets derived from the ontology, so entities found in documents link to the same IRIs as the data
Vendor agents kept inside the fabric: A2A for actions, MCP for shared meaning
Corrections routed to the owner of the context item, so every agent using it improves
Past a point, more context lowers answer quality. The aim is the right context, described by metadata on what each item means and how fresh it is.
One body, many owners. Part 1 of 3.
By Suman Banerjee
medium.com/data-science-coll…
#Ontology #LinkedData #ContextEngineering #ContextFabric #AgenticAI
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you’d like to be featured
Connected Data retweeted
Teaching agents to walk the graph: Wikidata Search Traces 🕸️
The semantic web was the original web of agents. Agentic LLMs have barely touched it.
A new paper from PleIAs, in collaboration with AI-BRIDGES and Wikimedia Deutschland, tests a convergence between two kinds of depth: graph traversal in a knowledge graph, and recursion in Recursive Language Models (RLMs).
In an RLM, the model works in a persistent Python environment, keeps intermediate results in state, and delegates selected evidence to sub-calls.
What they built:
A method for growing multi-hop questions over a frozen Wikidata snapshot (about 48M entities, 262M facts). Named entities are replaced with nested conditions, and each expansion is certified so the target stays unique and every condition is necessary
10,235 solving traces over single-entity and multi-hop questions
An open RLM harness with 13 graph functions
What the first evaluation shows, on 100 questions:
The harness improved both models tested, compared with direct tool calling over the same functions
gpt-6-luna went from 49 to 61 correct answers, doubling multi-hop accuracy (9 to 19 out of 50)
Qwen3.8-27B, open-weight and served on a single H100, went from 60 to 74, the top score of the evaluation
The gain comes from carrying the search further along the chain of conditions: models reach the target entity more often
The traces are meant for training. The next step is fine-tuning a smaller model, around 12B parameters, on them. The authors see wider potential here: recursively exploring graphs and texts may be a skill in itself, one that can be learned with far fewer parameters. Is that a path to a cognitive core for search?
Beyond Wikidata, they plan to study RLMs as a general approach to semantic data search across sources and ontologies.
By Mohamed Chenene, Carlos Rosas-Hinostroza, Anastasia Stasenko, Shani Evenstein Sigalov and Pierre-Carl Langlais
arxiv.org/abs/2610.06650
#Wikidata #RecursiveLanguageModels #AIAgents #OpenSourceAI #SemanticWeb
--
📩 The Year of the Graph Autumn 2026 newsletter issue is out!
Meaning, Traversal, Reasoning, Action: The Graph Stack for Agentic AI. 👇
yearofthegraph.xyz/newslette…
All things #KnowledgeGraph, #GraphDB, Graph #Analytics / #DataScience / #AI and #SemTech.
Subscribe and follow to be in the know. Reach out if you’d like to be featured




















