GraphNews

An agent's symbolic memory is a graph it keeps writing to. Facts are nodes, and typed links say how they relate. Growing that graph takes thousands of small judgements, and most memory systems pay a language model to make each one. Jev-Mem, from Jiang, Li and Li at UT Dallas, hands those judgements to Jev [1]. Jev is TypeSafe's decision model. It answers typed questions with a probability per option and writes no text. GPT-4o-mini is called only to write the final answer [1]. The work splits three ways. Code finds at most 10 existing memories near each new one [1]. Code also adds the links it can compute exactly, such as time order and shared names. Jev judges everything else. Is this memory a preference, an event or a procedure? Did the new remark cause the old one? Each question carries written criteria for yes and for no. The causal one rules out mere similarity and mere sequence. A link is kept when Jev scores it 0.60 or more [1]. Reading works the same way. Jev scores which kinds of link a question needs. After each round of search, it asks whether the evidence is enough, and search stops at 0.95 [1]. The graph only grows. Every 20 writes, Jev scores pairs of memories for contradiction, redundancy and staleness. A score of 0.85 adds a link recording what it found. Nothing is edited or deleted [1]. The test is LoCoMo, a benchmark of ten long conversations with questions about them [1]. Building the memory took 158 seconds. The fastest rival took 1,044. MAGMA, the authors' earlier system, took 1,404. Answers came in 0.93 seconds against 1.47 [1]. The accuracy gain is narrower than the headline. Overall the score rose from 0.700 to 0.777 [1]. About two thirds of that comes from trick questions about things never said. In the released test code, the answer prompt is told which questions are tricks. The paper does not say whether its table used that setting. Without that category the lead is 0.723 to 0.688 (my arithmetic). The paper never removes Jev to show what it adds on its own. It also says its scores are not calibrated probabilities [1]. A 0.95 need not mean right 95% of the time. That fact decides where such a model belongs. A wrong link costs little when links are only added, because the evidence stays and a later pass can mark the link as replaced. A wrong stop loses an answer. So let the decision model grow the graph, and fit its stopping threshold on your own labelled questions. Related work A-MEM, in 2025, had a language model link each new memory and update older ones as memories arrived [2]. In 2026, MAGMA split memory into four graphs: semantic, temporal, causal and entity [3]. Jev-Mem keeps MAGMA's four graphs and moves the structural calls to a typed decision model [1]. Together they point one way. The graph's shape is set by cheap, logged probabilities, and generation is kept for the answer.

"Context layer" is quickly becoming the next big category in enterprise AI. But there's a practical problem with how it's usually described: Before AI can use the context layer, someone has to build it. Define the ontology. Map every source. Normalize every field. Model every relationship. Keep the whole thing synchronized as the underlying data changes. That might work for a large enterprise with a dedicated data team. But it's a serious barrier for everyone else - and it delays the moment when an agent can actually do something useful. At RushDB, we're approaching this from the opposite direction. Start with the data you already have: - CRM records - Support tickets - Conversations - Payments - Product events - JSON, CSV, APIs, PostgreSQL, MongoDB It can be scattered. It can use inconsistent property names. It doesn’t need to fit a predefined schema. RushDB ingests it, infers types and structure, and uses an LLM to suggest how records across different sources may be related. Underneath, our Labeled Meta Property Graph model (LMPG) represents records, labels, properties, values, and relationships as interconnected graph elements on top of Neo4j. The important part is that properties become first-class citizens of the graph. This allows RushDB to discover and preserve structure as the data arrives, instead of requiring the entire data model to be designed upfront. The result is both: 1. A queryable graph for precise relationships and multi-hop questions 2. A semantic layer for retrieving information by meaning So an agent can move from: "What information sounds relevant?" to: "Which customers experienced payment failures, have more than two open support tickets, and showed negative sentiment during the past month?" That is what "agent-ready context" means to me. Not another static ontology project. A living, queryable structure that emerges from operational data, remains connected as that data evolves, and gives agents access to both meaning and relationships. Scattered data in Agent-ready context out https://rushdb.com/

Two projects building completely different things arrived at the same answer for how AI should remember. Neither seems aware of the other, maybe evidence for a solution landscape with a global minimum 🤔 The problem they tackle is something I try not to cover typically, but it keeps appearing in my box: AI agents doing real work over time need to remember stuff, not just a bit of chat, but accumulate facts and relationships as a conceptual network of the world. Some would argue that world geometry (physics) is inevitable in this direction but that's another topic altogether. Keyword search finds text that matches, similarity search finds things that resemble each other. Neither on its own follows the connections between things, like who reports to whom, what depends on what, what changed because of what etc. The two projects converging to the same are Omnigraph and Mnestic. Omnigraph treats a knowledge graph like a shared codebase. It's Rust, Arrow, and Lance (a versioned, columnar file format sitting directly on S3-style object storage). Multiple AI agents can each branch off the same graph, write independently, and merge back through a three-way, typed-conflict merge. It's git engineering applied to structured knowledge instead of code. A policy layer (Cedar) decides who can merge what before it lands. Mnestic, on the other hand, goes small and embedded, forked from CozoDB. It's a relational-graph-vector engine that runs Datalog queries instead of a dedicated graph query language. It's bitemporal and every write is timestamped along two axes (when a fact became true, plus when the database learned it). It runs in a single process, no infrastructure necessary, it can even run in a browser via WebAssembly. The two have a different philosophy, object-storage-native versus embedded, LPG schema versus relational Datalog, distributed multi-agent branching versus single-process bitemporal history. Yet, both landed on the identical core retrieval trick: fuse keyword search, vector similarity, and graph traversal into one ranked result using reciprocal rank fusion (RRF) rather than running three separate lookups and hoping the application layer sorts it out. Omnigraph does it declaratively as a query-file primitive while Mnestic does it as a Datalog-composable fixed rule with diversification built in. When two teams solving different problems independently converge on the same technique, that convergence is a stronger signal than either project's own claims about itself. I am not saying this conveys some absolute truth, I'm merely observing the similarities. Given more time I'm sure I would be able to see more matches across other projects since agent memory is really a very fertile domain. In fact, I see graph databases being rebranded as agent memory, because it's more appealing. - Omnigraph: https://www.omnigraph.dev - Mnestic: https://www.mnesticdb.com #AgenticMemory #KnowledgeGraphs

An ontology course on the Bookshop Trail: meaning, systematics, naming, definitions, design principles, and RDFS, SKOS and OWL 2 as one idea; every lesson measured.

Genie Ontology is not an ontology, at least not in the formal knowledge-representation sense. Databricks built Genie Ontology as a context layer for AI agents. Genie collects business semantics and context from Unity Catalog, Metric Views, dashboards, SQL, notebooks, and other assets. Genie then ranks that context by authority and relevance. That approach helps an LLM find useful context, but it does not give the enterprise one explicit and canonical model of meaning. A real ontology starts with concepts, not sources. Imagine that Salesforce uses “Account”, SAP uses “Business Partner”, a support platform uses “Organization”, and the warehouse uses “Customer”. Genie can retrieve all four representations and decide which source looks more authoritative. A formal ontology defines a canonical concept such as “Customer Organization” and maps each source-specific representation to that concept under explicit semantic conditions. This difference separates context federation from semantic integration. When sources disagree, the distinction becomes critical. Salesforce may treat opportunity value as “Revenue”. SAP may expose “Invoiced Revenue”. Finance may define “Recognized Revenue”. An executive dashboard may calculate “Recognized Revenue” net of refunds. Genie can rank those sources and choose context for the LLM. A formal ontology can define “Booked Revenue”, “Invoiced Revenue”, “Recognized Revenue”, and “Forecast Revenue” as distinct concepts. It can also define their relationships explicitly. The ontology removes part of the semantic burden from the LLM because the model already states what each concept means. A formal ontology can define class hierarchies, equivalence, disjointness, inverse relationships, cardinality restrictions, and logical axioms. A reasoner can derive facts and detect certain inconsistencies from those definitions. Genie does not currently document that kind of formal semantic reasoning. Genie primarily selects the enterprise context that an AI agent should use. I would therefore describe Genie Ontology as an authority-ranked enterprise context layer, not as a formal ontology. A formal ontology answers: “What does this concept mean, how does it relate to other concepts, and what logically follows?” Genie answers: “Which enterprise context should this AI agent use for this question?” The strongest architecture may use both. The ontology defines enterprise meaning. The semantic layer operationalizes that meaning. Genie retrieves the relevant context. The LLM reasons over that context. Databricks explains its approach here: https://lnkd.in/dSGVpPTQ #Databricks #Ontology #KnowledgeGraph #GenAI #SemanticLayer #DataArchitecture #EnterpriseAI | 33 comments on LinkedIn

7 practical solutions on how to work with SKOS in your data pipeline

A viral debate over loops versus graphs points to a bigger shift in how we build AI systems. Here’s what graph engineering actually means, how it differs from prompt, context, and loop engineering, and why it matters.

RDF and LPG both connect data. The bigger difference is what happens to the meaning behind those connections. RDF is built on open W3C standards and supports shared vocabularies, ontologies, and explicit semantics that can be reused across systems. That makes it especially valuable for enterprises building semantic layers and AI architectures where knowledge needs to remain open, interoperable, and reusable over time. Swipe through for a closer look at how RDF and LPG differ and why Open & FAIR principles matter for enterprise AI. #RDF #KnowledgeGraph #OpenStandards #FAIRData #EnterpriseAI #Stardog

Contribute to pwin/SPARQL_Course development by creating an account on GitHub.

Decision traces give AI agents persistent, queryable reasoning memory. Learn what they are, what they record, and how to capture them in a context graph with Neo4j.

Andrej Karpathy's wiki recipe helps solve a key problem in agentic AI, and you can scale it with a lightweight, easy-to-build knowledge graph.

Agent memory is highly complex, but getting it right is one of the most critical engineering challenges in building production-ready AI. As context windows grow, unoptimized memory architectures quickly lead to skyrocketing API costs and degraded performance. Investing time in a structured memory pipeline pays for itself instantly by saving massive amounts of tokens and capital. Knowledge graphs (KGs) are becoming a foundational pillar for modern agent memory architectures because they: - Enable efficient multi-hop reasoning (without burning loads of tokens). Instead of stuffing entire documents into the prompt window to find connections, an agent can query specific graph paths to retrieve only the relevant facts. - Can be cheaply updated to keep memory current. You can continuously insert, modify, or delete specific edges and nodes in real time without needing to re-index entire vector spaces or retrain underlying models. - Can trace reasoning paths across entities and relationships for transparency. Graphs naturally provide a clear, deterministic audit trail of how an agent arrived at a conclusion, making debugging and compliance straightforward. Extracting structured data to build these graphs can also be done remarkably efficiently using small encoder models like GLiNER2.5. Lightweight encoders can extract entities and relations deterministically, appending confidence scores in graph metadata. GLiNER2.5 can also extract all fields in a single forward pass, processing the entire input simultaneously rather than generating tokens sequentially. Because encoders process sequence representations in parallel rather than predicting text token-by-token, they eliminate the massive latency, high compute overhead, and hallucination risks typical of slow, expensive decoder-based LLMs. Knowledge graphs may seem old school, but they remain an exceptionally fast, cost-effective, and powerful framework for maintaining dynamically growing knowledge bases.

An agent should not be allowed to act on a meaning the business never settled.

A visual guide to how graph neural networks work under the hood

Contribute to MapRock/SemanticWebsOfMeaning development by creating an account on GitHub.