GraphNews

The Architecture of Meaning

Fundamentals and context as an use case of data operating systems.

Jaya Gupta’s thesis is right about context graphs, and wrong about who wins. In a world of heterogeneity, the integrator always wins, not the application.

We've been working on semantic representation for decades—knowledge graphs, ontologies, semantic layers. Jessica Talisman untangles what they actually are and what AI needs from them.

How shared meaning, evidence, and standards create durable semantic infrastructure

Google's real AI advantage is not Gemini. It is 15 years of structured knowledge. This article launches The Ontology Imperative, a series on building trustworthy agentic AI. Part 1a: what Google, Microsoft, and the smartest enterprises already know.

🎓Want to learn Gephi? Don’t think twice! I’m sharing five helpful learning resources ! 1.-Gephi Quick Start https://lnkd.in/gD6fPEJK 2.- Visualizing networks (Gephi) by Dr. Mathieu Jacomy https://lnkd.in/gwG_EtSb 3.-GEPHI – Introduction to Network Analysis and Visualization by Dr. Martin Grandjean https://lnkd.in/geeCDG4P 4.-Documentation for Gephi: core functions and plugins by Dr. Clément Levallois https://lnkd.in/gw6RPsrN 5.-Gephi Tutorials: Learning Resources for Everyone by Dr. Verónica Espinoza https://lnkd.in/gDq5XX-e _________ #Gephi #NetworkAnalysis #DataVisualization #NetworkVisualization #GraphTheory #DigitalMethods #ComputationalSocialScience #DataScience #OpenSourceTools #ResearchTools #SocialMedia #VisualAnalytics #ComplexNetworks #AcademicResearch

LLMs are a dead end.

Gemma 3 is at the core of Lettria’s new text-to-graph model that sets a new standard for enterprise-grade reasoning and reliability.

In a Nutshell: Context Graphs are not a replacement for Knowledge Graphs; they are an evolution that builds upon them. A Context Graph is effectively a Knowledge Graph + Time + Decision Lineage.

Google Makes Machine-Readable Metadata Great. Again! But standards and shared ontologies work differently for Google, Microsoft, and the enterprises.

The discussion about context graphs, which kicked off a couple of weeks ago in the AI/Semantics community, is now beginning to gain some steam.

What "semantics" actually is and what we should focus on

There is a lot of discussion going on about Context Graph and how they extend Knowledge Graphs. I think this discussion misses a very powerful aspect of the RDF stack (a language to represent knowledge graphs): named graphs.

Explore ArcadeDB's 2025 year-in-review, highlighting advancements in vector search, Python integration, gRPC, and storage efficiency

“If you skip data modeling before building a knowledge graph, you’re not innovating – you’re gambling.”

Forget context graphs. That's so last month...

How structured knowledge became healthcare’s quiet advantage

Building AI systems that don’t just make decisions, but remember and use the “why”.

...the pieces you need to know to start building an ontology for a knowledge graph

Part 1 — Generative Knowledge Modeling

“Ontology” used to be a cursed word.

Ontologies - why in the world would you ever need one?

Context Graphs: A Tangled Web Of Confusion 🕸️ With Context Graphs, I'm having loads of great discussions (with a lot of awesome critique and feedback - love it, helps me learn) 🙏 But also I see a lot, trying to mis-classify the problem space by overlaying other graph based solutions onto this one. There seems to be confusion about the space we are operating in. So, with that in mind, I thought I'd go back to basics. State Machines - concepts: ⚙️ - States are (where you are and where you can possibly move to) - Transitions (how you move) - Events (what triggers movement) - Guards (conditions that allow or block) The system is always in one state. They have a possibility space i.e. from the current position (state). Various options exist (some known and some unknown - this is key), but the path between them isn't predefined. Using the information available (context) a decision is made, results in a move to a different state. i.e. What happens next determines where you go, (GPS - dynamic re-routing vs routes marked on a Map) The path emerges from execution but isn't known ahead of time. Workflows vs State Machines ⚖️ Workflows (including procedural knowledge approaches): are predefined sequences of steps, the path is predefined and decreed up front e.g. Step 1 → Step 2 → Step 3. All options are not only known but the sequence is typically defined up front (although can evolve- but not typically at run-time) Note: trying to make workflows dynamic is trying to fit a square peg in round hole, probably can engineer, but it's the wrong pattern Both valid but very different behaviours for different problem spaces! 🤖 Agent → Uses State Machines 🔧 Traditional automation → Typically uses workflows How Agents navigate State Machines They observe state (current goal or state in its execution process), evaluate options and choose the next state based on context (all info needed to make the decision), then execute and arrive at new state. Agents also operate in an unknown state space i.e. they can create new options as they go. This fundamentally breaks predefined flow approaches. 💡 This repeats. The path isn't scripted, it's discovered at runtime. Context Graphs: A context graph is the structure an agent navigates: - Current state - Available transitions - Execution history + All the decision and other information used to make the decision to the appropriate transition (judgment, decision criteria etc, the "context" used) It's live at runtime and persisted as decision trace when complete, with the accumulated traces becoming organisational memory. Why The Confusion? 🤔 Context graphs sit at the intersection of data, software, and AI. Each discipline sees it through their own lens. We can def debate if the graph is just a log (the FC Capital POV) or also moves into the actual execution (what we've built) but first we must acknowledge the fundamental problem space we are in. The terminology will sort itself out ✌️ Nebulyx AI | 37 comments on LinkedIn

Starting the year with something we’ve been building quietly 🚀

From instance to structure to code to project ...