Showing posts with label architecture. Show all posts
Showing posts with label architecture. Show all posts

Enterprise Knowledge Representation: Conceptual Graphs, ISO Common Logic, and SAP Graph Foundations

Mike's Notes

This is part of a series of thoughtful opinions about using Ontology in software information systems.

Pipi has an existing BORO Engine (bor) (inspired by Chris Partridge's book "Business Objects: Re-engineering for Re-use"), but it runs in reverse: it imports triples to extract entities and relationships, then uses them to build reference relational databases for back-end industry workspaces.

Part seven: A post by Simon Polovina on the Ontolog Forum in response to the original post by  James Lee Stakelum.

A nicely formatted PDF of the same post is in the resources below.

Resources

References

  • Enterprise Knowledge Representation: Conceptual Graphs, ISO Common Logic, and SAP Graph Foundations, Simon Polovina. August 12, 2026

Repository

  • Home > Ajabbi Research > Library > Subscriptions > Ontolog Forum
  • Home > Handbook > 

Last Updated

24/08/2026

Enterprise Knowledge Representation: Conceptual Graphs, ISO Common Logic, and SAP Graph Foundations

By: Simon Polovina
Ontolog Forum: 12/08/2026

I bring Computer Productivity to Business Creativity by engaging in roles that draw upon my leadership and expertise in Enterprise Architecture and Conceptual Structures, which harmonise computer productivity with human and business creativity. My experience draws on Knowledge Representation and Reasoning, Artificial Intelligence, The Intelligent Enterprise, User Experience (UX), Design Thinking, Cloud, Data Infrastructures, SAP, Web, Service-oriented Architecture (SOA), Object-oriented Analysis and Design, and more. As well as NextGen industrial practice and education, I've published widely, with over 110 learned publications to date.

Abstract

This document presents a comprehensive discussion of the theoretical and practical role of Conceptual Graphs (CGs) in enterprise architectures, their comparative expressivity relative to First-Order Logic (FOL), Description Logics (OWL), and RDF, and their alignment with the ISO/IEC 24707 Common Logic. Additionally, it highlights recent perspectives on trustworthy AI, open vs. closed predicate grammars, and evaluates the comparative landscape of SAP Graph, SAP HANA Knowledge Graph, and SAP Business Data Cloud (BDC) Knowledge Graph across CGIF and CLIF representations.

1 Introduction & Conceptual Graphs Overview

Conceptual Graphs (CGs), developed by John F. Sowa (Sowa 1984), bridge human-readable visual semantics with formal mathematical logic. As introduced in previous foundational work (Polovina 2007), CGs provide a versatile environment for knowledge representation and automated reasoning that directly aligns with enterprise object models.

Key structural advantages of CGs over alternative formalisms include:

  • Visual Syntax with FOL Rigour: CGs use an intuitive visual bipartite graph syntax (concepts and conceptual relations) while maintaining an exact mapping via the -operator to First-Order Logic.
  • Native -ary Relations: Unlike RDF triples (), CGs support -ary relations without artificial reification.
  • Nested Contexts: CGs support nested propositional contexts, allowing clean modal, temporal, and belief representations.
  • Graph-Based Reasoning: Operations such as graph projection, join, and restriction enable sound structural reasoning without requiring resolution theorem provers.

This paper evaluates these theoretical properties within modern enterprise architectures. Specifically, we analyse the trade-offs of RDF-based knowledge foundations in SAP Business Data Cloud (BDC) and demonstrate how ISO/IEC 24707 Common Logic representations (CGIF and CLIF) provide a more robust substrate for neuro-symbolic AI.

2 Trustworthy AI, Common Logic, and Closed Grammars

Recent discussions surrounding multi-agent systems and local-first AI architectures highlight the crucial distinction between open-predicate systems and closed relational grammars (Stakelum 2026). Unconstrained open predicates (found in RDF, OWL, and raw Common Logic) incur an  integration bottleneck (the “Babel Tax”) when federating across independent domains.

By leveraging standardised specifications under ISO/IEC 24707 Common Logic (ISO/IEC 2018), architectures can combine bounded relational primitives with rich, open concept lattices (e.g., via Formal Concept Analysis), enabling sound neuro-symbolic reasoning without hallucination.

3 Comparing SAP Graph Architectures

Enterprise data foundations often combine multiple distinct graph paradigms. Table 1 outlines three core SAP graph technologies.

Comparison of SAP Graph Technologies

Feature/Aspect SAP Graph SAP HANA Knowledge Graph SAP BDC Knowledge Graph
Primary Purpose Unified API graph for cross-SAP integration In-memory graph engine for HANA Cloud analytics Business-context-aware semantic graph for AI
Scope Cross-SAP application data Technical graph database Business processes, roles, and policies
Data Sources S/4HANA, SuccessFactors, etc. Relational, spatial, and vector data in HANA SAP and non-SAP data with embedded context
Deployment SAP BTP SAP HANA Cloud SAP BTP (BDC Architecture)
Query Languages SPARQL, SQL SPARQL, Cypher, SQL SPARQL, SQL
AI Enablement High Medium Very High

Among these paradigms, the SAP BDC Knowledge Graph represents the most context-aware layer for enterprise AI. However, as evaluated in the following section, its technical implementation on an RDF triple-store foundation introduces structural friction that could be mitigated by a Conceptual Graph architecture.

4 Replacing RDF with Conceptual Graphs in Enterprise Data Foundations

Replacing Resource Description Framework (RDF) with Conceptual Graphs (CGs) in enterprise data foundations—such as the SAP Knowledge Graph capability and its technical implementation in SAP Business Data Cloud (BDC)—would fundamentally transform how enterprise AI, multi-agent systems, and business process models interact with underlying ERP data.

While SAP chose RDF for the SAP Knowledge Graph engine in SAP BDC primarily to leverage established SPARQL standards and existing triple-store tech, opting for a Conceptual Graph foundation would have solved several structural challenges inherent to large-scale ERP semantic layers.

4.1         Architectural Impact: RDF vs. Conceptual Graphs in Enterprise Systems
4.1.1     Eliminating -ary Reification in Complex Business Transactions

The RDF Reality: Standard ERP business entities rarely fit neat binary triples (). An SAP purchase order line item involves a vendor, material, quantity, plant, currency, pricing condition, and tax code. In RDF, representing this -ary transaction requires extensive reification or artificial intermediate nodes, bloating the number of triples into the billions and degrading SPARQL join performance.

The CG Advantage: CGs natively support -ary relation nodes linked directly to  concept nodes. A multi-party sales order or supply chain movement remains a single, unfragmented hypergraph node. This drastically reduces graph size, avoids join overhead, and makes the schema mirror actual SAP business objects (BAPIs/IDocs) directly.

4.1.2     Built-in Modal Logic for SAP Business Contexts

The RDF Reality: Enterprise data is deeply contextual. A price isn’t just “100 EUR”; it is valid from date  to , under condition type , within company code , and subject to a pending workflow approval. RDF lacks a native concept of contexts, forcing developers to resort to Named Graphs or  annotations—which break standard triple semantics and fragment reasoning engines.

The CG Advantage: Conceptual Graphs feature nested contexts as a core primitive. A belief state, a temporal validity window, a hypothetical “what-if” planning scenario, or an unapproved workflow step can be cleanly enclosed within a context box. Reasoning rules apply precisely inside specified contexts without leaking state into the broader knowledge base.

4.1.3     Direct Neuro-Symbolic Grounding for AI Agents (Joule & LLM Orchestration)

The RDF Reality: Modern enterprise architectures (like SAP’s Business AI Hub and SAP Knowledge Graph) use Knowledge Graphs to ground LLM agents and prevent hallucinations. However, converting LLM outputs into SPARQL triple patterns is notoriously fragile due to predicate drift, URI matching issues, and rigid triple structures.

The CG Advantage: CGs support graph projection—a sound and complete mechanism for pattern matching. An LLM acting as an abductive engine can propose a tentative solution in Conceptual Graph Linear Form (CGLF/CGIF). The engine uses projection to test if the proposed structure is a valid specialisation of an existing business rule or schema. If the projection fails, the logic engine rejects the hypothesis or pinpoints the exact ungrounded concept.

4.1.4     Convergence with ISO Standards

While RDF is a W3C web recommendation optimised for web-scale linking, CGs align directly with ISO/IEC 24707 Common Logic (ISO/IEC 2018). In enterprise ERP systems where auditability, compliance, and deterministic business rules are non-negotiable, having an underlying representation that translates losslessly into First-Order Logic provides a stronger governance guarantee than triple-store heuristics.

Structural Dimension SAP Knowledge Graph on RDF (in BDC) Conceptual Graph Alternative
Transaction Modelling Fragmented into binary triples via reification Native -ary structures preserving event unity
Business Contexts & Rules Named Graphs / Annotations (Ad-hoc) First-class Nested Contexts
Reasoning Mechanism Tableau-based subsumption / RDFS rules Graph Projection, Join, and Restriction
Agent AI Grounding SPARQL translation (prone to join complexity) Structural graph projection & unification
Schema Complexity Quadratic expansion of edge types (Babel Tax risk) Compact type hierarchies mapped to business objects


4.2 Why Didn’t SAP Do It?

The barrier has never been theoretical superiority—it has been ecosystem momentum. The RDF/SPARQL stack offered off-the-shelf open-source parsers, mature triple-store database engines, and an established developer base familiar with Semantic Web tooling. Implementing CGs natively would have required SAP to build and maintain a commercial-grade ISO Common Logic graph engine from scratch.

However, as enterprise systems pivot toward neuro-symbolic AI and local multi-agent orchestration, the architectural overhead of triple stores is becoming a bottleneck. Systems designed around -ary events, nested contexts, and graph projection are proving far better suited for grounding autonomous agents than legacy triple stores.

5 Formal Logic Representations: CGIF and CLIF
5.1 Conceptual Graph Interchange Format (CGIF)

Below is the linear CG serialisation of the comparison among the three SAP technologies, adhering, through CGIF,  to ISO/IEC 24707 standards (ISO/IEC 2018).

[Comparison: Study_SAP_Graphs] -
   (compares)-> [Technology: SAP_Graph],
   (compares)-> [Technology: SAP_HANA_Knowledge_Graph],
   (compares)-> [Technology: SAP_BDC_Knowledge_Graph].

[Technology: SAP_Graph] -
   (primaryPurpose)-> [Purpose: "Unified graph service for cross-SAP application integration"],
   (scope)-> [Scope: "Cross-SAP application data integration"],
   (deployment)-> [Platform: "SAP BTP"],
   (aiEnablement)-> [Rating: "High"].

[Technology: SAP_HANA_Knowledge_Graph] -
   (primaryPurpose)-> [Purpose: "Graph engine for storing/querying connected data in SAP HANA Cloud"],
   (scope)-> [Scope: "Technical graph database in HANA Cloud"],
   (deployment)-> [Platform: "SAP HANA Cloud"],
   (aiEnablement)-> [Rating: "Medium"].

[Technology: SAP_BDC_Knowledge_Graph] -
   (primaryPurpose)-> [Purpose: "Business-context-aware graph for AI-driven process automation"],
   (scope)-> [Scope: "Business semantics, processes, and context"],
   (deployment)-> [Platform: "SAP BTP"],
   (aiEnablement)-> [Rating: "Very High"].

5.2         Common Logic Interchange Format (CLIF)

The corresponding ISO 24707 CLIF representation provides a direct Lisp-style S-expression syntax suitable for first-order logic provers.

(cl-text SAP_Graph_Comparison_Ontology

  (cl-comment "Root Comparison Structure")
  (Comparison Study_SAP_Graphs)
  (compares Study_SAP_Graphs SAP_Graph)
  (compares Study_SAP_Graphs SAP_HANA_Knowledge_Graph)
  (compares Study_SAP_Graphs SAP_BDC_Knowledge_Graph)

  (cl-comment "SAP Graph Assertions")
  (Technology SAP_Graph)
  (primaryPurpose SAP_Graph "Unified graph service for cross-SAP application integration")
  (deploymentEnvironment SAP_Graph SAP_BTP)
  (aiEnablementLevel SAP_Graph High)

  (cl-comment "SAP HANA Knowledge Graph Assertions")
  (Technology SAP_HANA_Knowledge_Graph)
  (primaryPurpose SAP_HANA_Knowledge_Graph "Graph engine for storing/querying connected data in SAP HANA Cloud")
  (deploymentEnvironment SAP_HANA_Knowledge_Graph SAP_HANA_Cloud)
  (aiEnablementLevel SAP_HANA_Knowledge_Graph Medium)

  (cl-comment "SAP BDC Knowledge Graph Assertions")
  (Technology SAP_BDC_Knowledge_Graph)
  (primaryPurpose SAP_BDC_Knowledge_Graph "Business-context-aware graph for AI-driven process automation")
  (deploymentEnvironment SAP_BDC_Knowledge_Graph SAP_BTP)
  (aiEnablementLevel SAP_BDC_Knowledge_Graph VeryHigh)

  (cl-comment "General Inference Rule")
  (forall (x)
    (if (and (Technology x)
             (deploymentEnvironment x SAP_BTP)
             (aiEnablementLevel x VeryHigh))
        (BusinessContextAware x)))
)

6 Conclusion

While modern enterprise platforms such as SAP Business Data Cloud have successfully adopted RDF triple stores to build context-aware Knowledge Graphs, standard binary triple models introduce significant overhead when representing complex -ary business transactions and nested modal contexts. As demonstrated in this analysis, adopting Conceptual Graphs (CGs) directly resolves these structural bottlenecks through native -ary relations, first-class nested contexts, and graph-projection reasoning.

Furthermore, grounding enterprise architectures in ISO/IEC 24707 Common Logic provides the deterministic First-Order Logic rigour required for trustworthy neuro-symbolic AI and autonomous agent orchestration. By formalising enterprise semantic layers in standardised serialisations like CGIF and CLIF, enterprise architectures can bypass the combinatorial integration challenges of unconstrained open predicates while guaranteeing verifiable, hallucination-free decision support across complex business domains.

References

  1. ISO/IEC. 2018. ISO/IEC 24707:2018 Information technology — Common Logic (CL): A framework for a family of logic-based languages. International Organization for Standardization.
  2. Polovina, Simon. 2007. “An Introduction to Conceptual Graphs.” In Conceptual Structures: Knowledge Architectures for Smart Applications. Proceedings of the 15th International Conference on Conceptual Structures (ICCS 2007), edited by Uta Priss, Simon Polovina, and Richard Hill, vol. 4604. Lecture Notes in Artificial Intelligence. Springer-Verlag. https://doi.org/10.1007/978-3-540-73681-3_1.
  3. Sowa, John F. 1984. Conceptual Structures: Information Processing in Mind and Machine. Addison-Wesley.
  4. Stakelum, James Lee. 2026. The Architecture That Makes AI Trustworthy Wasn’t Invented. It Was Discovered. Review of the Ontology Summit 2026 Presentation by Arun Majumdar and John F. Sowa.
By , No comments:
Tags , ,

IT-ontology. one more definition

Mike's Notes

This is part of a series of thoughtful opinions about using Ontology in software information systems.

Pipi has an existing BORO Engine (bor) (inspired by Chris Partridge's book "Business Objects: Re-engineering for Re-use"), but it runs in reverse: it imports triples to extract entities and relationships, then uses them to build reference relational databases for back-end industry workspaces.

Part six: A post by Michael DeBellis that criticises something John F Sowa wrote on the Ontolog Forum and James Lee Stakelum's views on SGF. I added the names of people quoted to make the robust exchange of views clearer for me.

Resources

References

  • A Universal Moral Grammar (UMG) Ontology, Michael DeBellis, 2018.

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

20/08/2026

IT-ontology. one more definition

By: Michael DeBellis
Ontolog Forum: 19/08/2026

Michael DeBellis is a Semantic Web and AI consultant and researcher with over 40 years of experience in industry and academia. He began designing ontologies in the early 1980s while building expert systems for Accenture and later worked as a researcher at USC’s Information Sciences Institute (ISI), where he used Loom — a direct predecessor to the Web Ontology Language (OWL). Throughout his career at firms including Deloitte, Accenture, and ThoughtWorks, he has focused on applying advanced technology to real-world enterprise challenges. His work emphasizes the practical integration of Semantic Knowledge Graphs into complex systems, highlighting the importance of user requirements, legacy data, and enterprise architecture over purely theoretical modeling. He has published and presented internationally on a broad range of topics across multiple domains​.

John F Sowa

Protégé was designed to use OWL,  which is dead end technology.  There is a huge amount of obsolete OWL software, and it must be supported indefinitely.  But new applications should never be based on OWL.  

Michael DeBellis

That's a pretty strong statement and I didn't see anything strong enough to support such a statement in the linked to article: https://medium.com/@JamesStakelum/why-the-triple-is-the-wrong-grain-1cad99e136f4

For example he says: 

James Lee Stakelum

Failure 1: The triple cannot represent an event as a whole.

RDF/OWL representation (five triples):

:Beethoven rdf:type :Composer .
:NinthSymphony rdf:type :Symphony .
:Beethoven :composed :NinthSymphony .
:NinthSymphony :composedIn :Vienna .
:NinthSymphony :composedInYear "1824" .

Michael DeBellis

And contrasts that with: 

James Lee Stakelum

SGF provides the Synapse — a hub‑and‑spoke structure. The verb is the hub (the VerbHub). Participants attach through exactly 15 fixed semantic roles.

Synapse: s1
VerbHub: compose
HAS_AGENT: Beethoven
HAS_PATIENT: Ninth_Symphony
HAS_LOCATION: Vienna
HAS_TIME: 1824

One object. The VerbHub is not an edge label. The event is whole. 

Michael DeBellis

You could do that with OWL too. Create a subclass of Event called Compose:

Event: Compose_Ninth_Symphony
rdf:type: Compose (subclass of Event)
HAS_AGENT: Beethoven
HAS_PATIENT: Ninth_Symphony
HAS_LOCATION: Vienna
HAS_TIME: 1824

I had a model exactly like this, including using a property called has_patient for Agents that were impacted by an Event, in the first OWL ontology I ever wrote about called the Universal Moral Grammar. https://www.academia.edu/53542647/A_Universal_Moral_Grammar_UMG_Ontology  

His argument about not being able to define provenance also seemed weak:

James Lee Stakelum

Failure 2: The triple cannot carry its own provenance.

:Beethoven :composed :NinthSymphony .

This triple is structurally identical whether it came from a scholarly biography or a random comment. Named graphs are optional — provenance can be stripped in transit.

This is a limitation of OWL compared to Property Graphs if we are just talking about properties. In OWL there is no way to associate metadata with a specific triple because the triple is implicit, there is no data structure for each instance of a relation. But he actually describes a solution to this when he says "Named graphs are optional — provenance can be stripped in transit." This is one thing I've come to realize in the last few years going from prototypes to actual systems integrated with real data: named subgraphs are essential for many use cases of large RDF graphs in the real world. E.g., in Stardog they aren't optional. You have to put certain kind of data such as data inferred by the reasoner, into specific sub-graphs. 

Michael DeBellis

I agree, one obvious use for subgraphs is for metadata, another is for defining security and encapsulation boundaries. But the fact that they are optional hardly seems like a reason to just completely throw OWL away. You can just make them non-optional with standards the way Stardog does. And you can also deal with the property problem by just reifying the property. I.e., turn a property into a class so when you create an instance of the relation you create an instance of the class. This pattern is much older than OWL. It's one of the most standard patterns used in OOP.  I imagine most readers know it well but in case you don't: https://www.w3.org/TR/swbp-n-aryRelations/

In this example, we already did the reification in the previous case when we created a subclass of Event called Compose. We could use that to solve the provenance problem as well: 

Event: Compose_Ninth_Symphony
rdf:type: Compose (subclass of Event)
HAS_AGENT: Beethoven
HAS_PATIENT: Ninth_Symphony
HAS_LOCATION: Vienna
HAS_TIME: 1824

has_source: https://en.wikipedia.org/wiki/Symphony_No._9_(Beethoven)

He also says:

James Lee Stakelum

Failure 4: The triple cannot carry its own grounding.

The URI :Beethoven points to a document, not a concept. Is it the composer, the dog, the crater? 

Michael DeBellis

That's not true. Just because it is an IRI doesn't mean it points to a document. He's confusing IRIs and URLs. 

And his solution is:

James Lee Stakelum

The triple cannot carry its own disambiguation. Therefore every identifier must carry its own sense‑level distinction and trace to a shared foundation.

SGF provides the Canonical ID: en.beethoven.ludwig_van_beethoven.person.core. The microgloss ludwig_van_beethoven distinguishes this sense from others. Every Canonical ID has a finite IS‑A path to the Prime Registry — approximately 65 irreducible semantic primes (DO, HAPPEN, SOMEONE, SOMETHING, GOOD, BAD, etc.). Paths terminate at primes. No infinite regress.

Michael DeBellis

That kind of universal ontology for the entire enterprise goes against the best thinking  from people like Dehghani, Fowler, and Evans about Domain Driven Design (the state of the art for Microservice design) and Data Mesh (the state of the art for Data Products which are the microservice equivalent for data). One of the core ideas behind both is that one model for the entire enterprise is an anti-pattern. Not to mention I can't imagine how that kind of highly centralized model is going to work with petabytes of data. It goes against one of the core directions that I see in modern software development: adoption of truly distributed programming. It's why functional programming is finally no longer only for nerds because functional programs (e.g., the Map-Reduce algorithm used with Apache Hadoop and Spark) are great at dealing with highly distributed data. 

But I have a feeling we may be debating apples and oranges. I'm talking about what people building systems that have to deal with petabytes of data and integrate with LLMs should use now and I think OWL and Semantic Web technology make a lot of sense. I mentioned this before but it's worth repeating: the last couple of years I read several books by thought leaders about managing enterprise data: Strengholt, Dehghani, Olesen-Bagneux, and all of them have requirements that are virtually a perfect match for Semantic Web technology: 

  • Use URLs for persistent IDs
  • Use standards
  • Explicit representation of metadata (includes semantic metadata)
  • Graph models and databases
  • Implementation-independent domain models
  • Active metadata (e.g., automated reasoning)
  • Powerful and flexible search

There are also real world examples that are being built. One of the issues with tech like this is that the people who use it don't want to talk about it because they see it as a competitive advantage but I can say from first hand experience it is being used at several tech leaders in the industry. One company that will talk about it is a German company that makes parts for modern cars. They built a Semantic Data Catalog using OWL, RDF, and standard W3C vocabularies such as DCAT and PROV. A paper from those guys is attached. 

Getting back to whether we're talking research or real world. Here is a list of the most popular database vendors right now: https://db-engines.com/en/ranking  

It's kind of depressing how Neo4j is so far above the nearest RDF triplestore. But at least all the major RDF triplestores are on the page. I didn't see a single product that uses The Symbol Grounding Framework (SGF) in that list. 

Michael

https://www.michaeldebellis.com/blog

By , No comments:
Tags ,

What is SGF?

Mike's Notes

This is part of a series of thoughtful opinions about using Ontology in software information systems.

Pipi has an existing BORO Engine (bor) (inspired by Chris Partridge's book "Business Objects: Re-engineering for Re-use"), but it runs in reverse: it imports triples to extract entities and relationships, then uses them to build reference relational databases for back-end industry workspaces.

Part five: An article by James Lee Stakelum that summarises SGF. A PDF is also available.

Resources

References

  • SGF: The Symbol Grounding Framework, James Lee Stakelum. GitHub. 2026.

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

18/08/2026

What is SGF?

By: James Lee Stakelum
Medium: 11/08/2026

I'm deep into building an architecture for structured knowledge, and using AI to create cinematic quality movies.


The SGF (Symbol Grounding Framework) project is moving fast!

Six volumes have been published on Amazon. The GitHub repository contains formal RFCs, reference implementations, and numerous essays. The architecture has grown from a single insight about dictionaries into a seven-layer stack with three core components: a governance language called ‘Omega’ that enforces what the machine CAN, MAY, and DO; a machine-to-machine protocol called HFF that lets machines communicate with zero prior integration; and an operating system for autonomous systems that has a constitution, the ability to mint new laws — as long as they are constitutional — and sovereignty: the power to refuse outside instructions that violate its own rules.

But there’s a problem: the information about SGF is spread across several books, RFCs, published code, and essays. If you want to understand “what is SGF?” you currently need to read six books and several thousand lines of specification.

I’m working on a new book that puts everything into one book, but decided as an interim solution to consolidate the big picture into a single white paper. I will provide the link to the white paper below.

But first, let me give you the overview — the five-minute talk I would give if I were standing in front of a room describing SGF.

...

SGF is a deterministic Semantic Infrastructure. It lives in the broader space of Verifiable Knowledge Infrastructure — systems that can represent meaning, verify it, trace it to its source, and govern actions based on it.

First, let me give you the back-story.

When I first started the SGF project, began by writing code to transform prose from textual documents (PDFs, wikipedia articles, etc) into a structured format and storing it in a knowledge graph, so that human knowledge could be stored in a structured format that LLMs could use, instead of RAG, so it would be easily inspectable and verifiable (you dont normally see where an LLM got its facts), and be tagged with provenance showing where each fact came from, etc.

I began searching for a structure that could hold meaning at the grain of a clause. A sentence might span multiple clauses and therefore is not the right grain. A RDF triplet is too small for my intended purposes for many reasons I have explained elsewhere in SGF essays.

Thematic role theory was a natural fit. Thematic role theory deconstructs a clause into a core predicate and a set of universal semantic roles that define how participants in the clause relate to the action, independent of surface grammar. Rather than relying solely on grammatical labels like subject or object, the framework maps sentence participants to specific semantic functions — such as agents, patients, instruments, and goals — governed by the intrinsic argument structure of the verb.

Using thematic role theory, I arrived at a hub-and-spoke structure — one verb, its participants, their roles — without shattering it across multiple fragments. That search led to an architecture.


First: a schema and grammar for structured knowledge.

Most knowledge representations use triples — subject-predicate-object. Triples fragment events. An event that involves an agent, a patient, a time, a location, an instrument, and a reason shatters across multiple triples, losing the structural integrity of the original claim.

SGF uses a Synapse — a verb hub with exactly 15 fixed thematic roles. These roles come from 50 years of cross-linguistic research in thematic role theory — Fillmore, Jackendoff, FrameNet. They are not arbitrary. They are the discovered universal slots through which participants attach to events.

Every clause compiles into exactly one Synapse. No event fragments. The roles are closed, which means integration cost drops from N² to N. An engineer does not need to learn a new relationship vocabulary for each domain. The same 15 roles serve contracts, medical guidelines, military operation orders, and manufacturing specifications.

Every Synapse carries its provenance — source document, section, sentence, offset. Every Synapse carries its epistemic status — is this a core definition, a sourced observation, an inferred conclusion, or a ghost that the system knows exists but cannot yet resolve? SGF does not decide who is telling the truth. It records what was said, by whom, and with what source. Truth is resolved at query time, not ingestion time.

I’m a bit embarrased to say that early in the SGF project, I naively assumed all thought was atomic. Like “Ludwig van Beethoven was born in 1770” is an example of what I would consider an atomic thought. It can stand alone, as long as you can tether each term to a dictionary that tells you what each term in that sentence means. But the recipe to bake a chocolate cake is not atomic. Each step is an atom, and to extend the metaphor, I needed linking mechanisms to join the atoms in meaningful ways. That led me to linking types.

Synapses compose into larger structures via 8 link types — CAUSES, SUPPORTS, CONTRADICTS, PRECEDES, DEPENDS_ON, and others. A recipe, a contract, a military operation order is molecular, not atomic.

And, furthermore, these larger structure are composable into even larger structures.

...

Second: a recipe for bootstrapping a shared dictionary — the dictionary itself is not mandatory, but the network effects are real.

Language is a lossless compression algorithm. We say “wagon” instead of saying “a container mounted to an axle with wheels and a hitch so it can be pulled.” We compress complex cognitive scripts into single tokens because the serial interface of speech is slow. Compression lets us transmit meaning faster than we could decompress it.

But compression without decompression is just noise. Most dictionaries fail at decompression because they are lossy — they define complex words using other complex words. Pail equals bucket. Bucket equals pail. The chain never terminates.

SGF’s approach is different. The architecture requires that two parties agree on a shared dictionary. Any dictionary. Your organization’s existing ontology. An industry-standard taxonomy. A custom-built lexicon. What matters is that both parties point to the same reference and agree that when they use a Canonical ID from that dictionary, they mean the same thing.

If you already have a dictionary, use yours. The architecture does not care which dictionary you choose. It cares that you agree on one.

What SGF provides as a convenience is the Synapedia — a recipe for bootstrapping a very large dictionary from open sources. WordNet for core vocabulary. Wiktionary for long-tail coverage across hundreds of languages. Wikipedia for world knowledge. The bootstrap scripts are on GitHub. Given the same snapshot and pipeline, any party can rebuild a conformant Synapedia in hours and verify its content hashes.

The Synapedia is a design pattern template. It shows you how to structure a shared dictionary with Canonical IDs, microglosses, IS_A chains, polyhierarchy, and prime grounding. You can follow the same pattern with your own dictionary.

There is a network effect, and it is real. Like the fax machine, the value of a shared dictionary compounds with each additional party that agrees to use it. The first integration takes time. The tenth is faster. The hundredth is nearly automatic.

What is mandatory is the Canonical ID — the structured identifier that carries disambiguating meaning in the ID itself. en.bank.financial_institution.noun.core. Not a UUID. Not a random string. The language, the lemma, the microgloss, the part of speech, the namespace — all in the ID. Two systems that have never communicated can resolve this ID to the same sense without a prior agreement.

And what both parties must have is their own private lexicon — an in-house dictionary for the terms unique to their world. Internal product codes. Organizational jargon. These live in the private lexicon, not in the shared dictionary. When they cross a boundary, the message includes a dictionary segment for each private term, tethered to the shared dictionary via binary ontological links.

The relevant links include:

  • IS_A — connects a concept to its parent concept. A water_pump IS_A pump.
  • INSTANCE_OF — connects a specific individual to its concept class. A pump with serial number ABC123 INSTANCE_OF water_pump.
  • HAS_PART, HAS_ATTRIBUTE, SAME_AS and others.

IS_A and INSTANCE_OF are distinct. IS_A operates between concepts. INSTANCE_OF operates between an instance and a concept. Ontologists care about this distinction, and they are right to care.

Not all prose is suitable for this. Joyce’s Ulysses will produce more GapReports than Synapses — and that is by design. The system does not pretend it can parse everything.

At the bottom of every IS_A chain: 65 semantic primes from the Natural Semantic Metalanguage. Irreducible concepts like SOMEONE, SOMETHING, DO, HAPPEN, GOOD, BAD, THINK, FEEL, BODY. If a term cannot reach a prime — if it is a hallucination, a fabrication, a term that has no route to shared ground — the system returns UNKNOWN. It does not fabricate. It does not guess. It reports the gap.

...

A note on how this relates to existing ontology standards.

This is the dual-axis alignment, and it is one of the most important things to understand about SGF.

BFO and CCO — the ontology standards the DoD and Intelligence Community have adopted — guarantee formal consistency. They answer: “Does this classification respect our axioms?” They do not answer: “Does this concept correspond to anything real?” An LLM might fabricate a “chronospatial dampening array,” BFO might classify it as Artifact → Independent Continuant, every axiom satisfied, and the system accepts a fabrication with mathematical certainty.

SGF operates on two separate axes to address this.

Axis 1 — The semantic axis. This handles human language — cognition, intent, compression, decompression, metaphor, social constructs. It is grounded in 65 NSM primes. Its purpose is anti-hallucination: every term must trace an IS_A chain back to bedrock or the system returns UNKNOWN. This axis answers: “Does this concept correspond to anything we can ground in shared meaning?”

Axis 2 — The ontological axis. This handles institutional compliance — BFO, CCO, audit trails, export to formal standards. Its purpose is consistency across systems: when an entity leaves SGF’s internal runtime and enters the institutional record, it must speak the language that review boards, regulators, and partner systems already understand. This axis answers: “Does this concept satisfy our formal classification axioms?”

These are separate axes because meaning and existence are different things, modeled by different frameworks, serving different purposes. No single framework can serve both. That is why SGF keeps them on separate axes, connected by a deterministic bridge that translates without conflating.

The bridge between them is a set of transformation rules. The semantic runtime preserves terms as they appear in human language. At the export boundary, those terms are mapped to their closest BFO categories, with documentation annotations where the mapping is imperfect. The bridge is one-directional by default — from the semantic runtime outward to the institutional record — because the ingestion pipeline must remain open to human language, while the export boundary must speak the language of formal ontology.

I want to be clear about where SGF currently stands. Formal BFO certification is not an active project focus today. The current focus is engineering the architecture, producing working code, and finding implementation partners. But the architecture is designed for this alignment from the ground up.

The mapping is not always clean. Consider a hole. NSM says a hole is a THING — it has location, shape, it can be created and destroyed. Language treats holes as entities. BFO says a hole is not an Independent Continuant — it is a fiat surface, a dependent entity. SGF does not hide this tension. It preserves the term on the semantic axis and maps to the closest category on the ontological axis, with documentation explaining the discrepancy.

BFO ensures consistency. NSM ensures truth. Together, they provide what neither can provide alone.

...

Third: a protocol for machine-to-machine communication that requires zero prior integration.

Most integrations are pairwise. Every pair of systems requires bespoke ontology mapping, data format alignment, and policy negotiation. The cost scales as N².

SGF’s protocol layer — HFF (Honest Fact Forwarding) and AFP (Act Framing Protocol) — lets two machines that have never met exchange meaning on first contact. Both share a dictionary. The sender brings its own definitions for terms not in the shared dictionary, tethered to it via binary links. The receiver follows the links back to shared ground.

Why does AFP matter? A robot that parses “Can you pass the salt?” as a yes/no question about physical capability, confirms it can, and then does nothing — that is the failure AFP prevents. AFP declares what act the message is performing. Thirteen act types — INFORM, COMMAND, PROMISE, REFUSE, CONFIRM, ERROR, and others — tell the receiver whether this is a statement, a request, an order, or a promise. The same payload wrapped in INFORM versus COMMAND goes through completely different authority gates.

Every message passes through five integrity gates: schema validation, hash verification, signature verification, freshness check, and lexicon hydration. A message that fails any gate is rejected. A message that passes all five is a candidate for admission — not an instruction to obey. The receiver remains sovereign.

...

Once I had the dictionary, I realised… Each layer exposed the absence of the next.

This is how the architecture grew. I started with the grammar and the dictionary. Once I had those, I realized two machines that wanted to exchange this structured meaning needed a protocol. That led to HFF and AFP. Then I realized governance could not be a prose prompt. That led to Omega. Then I realized the system needed a way to learn from its own experience. That led to Wisdom Harvesting.

Each layer exposed the absence of the next. The architecture was not designed in a single pass. It was discovered through building.

...

Fourth: an operating system with a small stable kernel, continuous learning of wisdom, sovereignty, and the ability to mint new laws.

Knowing what a message means is not the same as knowing whether the requested action is permitted.

Omega is a governance language with exactly 13 primitives. It is non-Turing-complete. It is compiled at load time. It is fail-closed — no matching rule means DENY. CAN → MAY → DO is enforced as a structural constraint, not a suggestion. A machine that can parse a command cannot execute it unless a compiled rule explicitly permits it.

The Event Horizon separates probabilistic reasoning from deterministic action. The LLM proposes. The governance layer decides. The actuator executes only when the governance layer says ALLOW. The kernel — small, deterministic, never-changing — mediates the crossing. It cannot be overridden at runtime.

Wisdom Harvesting sits above the stack, monitoring every interaction, extracting cross-domain principles, and storing them in a retrievable corpus. The kernel does not modify itself. It accumulates wisdom. A rule learned from a database connection timeout — “release finite shared resources after use” — is surfaced when a mutex deadlock occurs in an entirely different context months later.

The machine has sovereignty. It can refuse a command that violates its constitution. It can mint new laws within constitutional constraints, adapting to novel situations that were not anticipated at design time.

...

And it compounds.

This part matters more than I have let on so far.

Most systems do not learn. They are loaded with knowledge at deployment, and that is all they ever know. SGF is different. Above the stack sits a Wisdom Harvesting pipeline that monitors every interaction — every GapReport, every governance decision, every alignment failure, every success — and extracts cross-domain principles from them.

A rule learned from a database connection timeout — “release finite shared resources after use” — is surfaced months later when a mutex deadlock occurs in an entirely different context. A lesson from aerospace manufacturing — “when a provenance chain has been incomplete for two consecutive batches, escalate verification depth” — appears in an industrial robotics setting where the system has never encountered aerospace data.

The kernel never changes. It stays small, deterministic, certifiable. The wisdom grows above it, accumulating with every operation, every failure, every success. The system gets better with use.

This is not a feature. It is a different category of system.

...

Design patterns have emerged from using this architecture.

SOAM aligns Synapse Trees node by node across five dimensions — branch matching, concept matching, constraint comparison, frame alignment, and modality alignment. Every failure produces a GapReport. The Decider produces one of five outcomes: ACCEPT, REJECT, CONDITIONAL, CLARIFY, or ESCALATE. The system never guesses.

The Returns Pattern lets a warehouse identify a returned part that has no packaging and no SKU label. The system uses visual features and verbal descriptions, aligning against the catalog through the same depth hierarchy that serves specification verification.

The Privacy-Preserving Verification Pattern lets a contractor prove a component meets a specification by exporting an 86-character fingerprint and pass/fail flags. No proprietary data leaves the air gap.

Each pattern is a reusable solution to a problem that previously required bespoke engineering.

...

Every formalism leaves a remainder. SGF does not claim to have closed the gap between structure and meaning. It provides mechanisms for inhabiting that gap honestly.

The GapReport is not a failure mode. It is a design feature. When the system cannot ground a term, assign a role, resolve a pronoun, or classify a clause, it says so. It does not fabricate. It does not guess. It produces a structured report naming exactly what is missing.

A court reporter does not decide who is telling the truth. The court reporter records what was said. SGF is that court reporter for machine meaning.

...

The full white paper covers all of this in depth.

It describes the complete seven-layer stack, the dual-axis ontological alignment, the formal evaluator model for Omega, the Wisdom Harvesting pipeline, the convergence argument, the honest claims, and the implementation status.

The PDF and Markdown versions are on GitHub:

The repository also contains numerous essays, the RFCs, and working code for bootstrapping the shared dictionary and for transforming prose into structured format.

I’m moving as fast as I can, and there’s more code that still needs to be written. The code I’ve written is intended to help get you started. You may want code in your own language of choice. I purposely wrote the RFCs in a form that, mostly, can be compiled into code of your preference — Python, C++, Java, Rust.

A closing thought.

I started with some simple questions: can we build a decompression mapping for language? Can we reverse the compression that turns a container mounted to an axle with wheels and a hitch into ‘wagon’? Can we build a process that compiles prose into a structured format, with each term tethered to a shared dictionary?

The answers turned out to be yes. And that unlocked an operating system — a system that can represent meaning deterministically, share it across trust boundaries with zero prior integration, govern its own actions through a written constitution, and compound its expertise over time.

The architecture is open. The code is Apache 2.0. The standards are published as RFCs.

The question is not whether this is possible. The question is what we will build with it.

By , No comments:
Tags , ,

The Architecture That Makes AI Trustworthy Wasn’t Invented. It Was Discovered

Mike's Notes

This is part of a series of thoughtful opinions about using Ontology in software information systems.

Pipi has an existing BORO Engine (bor) (inspired by Chris Partridge's book "Business Objects: Re-engineering for Re-use"), but it runs in reverse: it imports triples to extract entities and relationships, then uses them to build reference relational databases for back-end industry workspaces.

Part four: An article by James Lee Stakelum that reviews Permion, its architecture and some options.

Resources

References

  • Business Objects: Re-engineering for Re-use, Chris Partridge. 2005.

Repository

  • Home > Ajabbi Research > Library >
  • Home > Handbook > 

Last Updated

17/08/2026

The Architecture That Makes AI Trustworthy Wasn’t Invented. It Was Discovered

By: James Lee Stakelum
Medium: 14/07/2026

Epistemic architect and creator of the Symbol Grounding Framework, AI operating systems, machine governance languages, and zero‑integration machine‑to‑machine communication.

...

John Sowa and Arun Majumdar demonstrated a breakthrough inference engine at the 2026 Ontology Summit — twelve agents on a laptop, no GPU, refusing to guess. But the architecture beneath it inherits an open-predicate model that has failed at scale every time it has been tried. This article reveals the convergence between Permion’s engineering and an open architecture called the Symbol Grounding Framework, and explains why the bridge between them will define the next decade of trustworthy AI.

...

1. The Scene

The Ontology Summit. June 3, 2026. John Sowa takes the virtual podium. He is 86 years old. Co-author of the ISO 24707 Common Logic standard. Creator of conceptual graphs. Six decades of work in knowledge representation.

He begins, as he often does, with a warning.

“Anything generated by LLMs is basically a hypothesis,” he says. “It’s a best guess. If it’s inconsistent with the ontology or a verified database, it might be rejected as false.”

This is vintage Sowa. He has been saying this since before LLMs existed. The message is not new. What is new is the context. He is speaking as a Fellow of Permion, a company that just won the G7 GovAI Grand Challenge against over a hundred submissions from across the G7 and EU.

Then Arun Majumdar, Permion’s CEO, takes over. He opens a terminal on a standard MacBook Pro — an Apple M1 Max from 2021, 64 GB of RAM, no GPU. He runs a command. The machine starts processing 100 HTML documents. It uses a graph-based ranking algorithm derived from TextRank, co-authored by the late Paul Tarau, a Permion researcher. It selects the relevant documents. It runs twelve LLM agents simultaneously. Each contributes to a structured threat assessment report. The system processes 9,000 tokens per second. The logic engine — built on Definite Clause Grammars and Common Logic — governs the entire process. If an agent cannot answer, it does not guess. The final report is structured, cited, and formatted precisely.

Twelve agents. On a laptop. No cloud. No GPU.

This is not a vaporware demo. This is running on hardware anyone can buy.

...

2. What Permion Actually Achieved

The demo deserves attention on its own terms.

Running twelve LLMs simultaneously on a consumer laptop represents a fundamental shift in how AI systems can be deployed. Most multi-agent architectures require cloud infrastructure — GPU clusters, high-bandwidth interconnects, centralized orchestration. Permion’s approach runs locally. Every document stays on the machine. Every inference happens on the device. No data leaves the air gap.

Their disk streaming technology is a genuine engineering achievement. Instead of loading entire models into RAM, it indexes the model, predicts which tensors will be needed for a given query, and streams only those tensors from SSD to memory. A system that cannot fit in RAM can still run in real time.

Their Definite Clause Grammar provides semantic constraints that regular expressions cannot express. Variables carry type restrictions. The grammar knows what kind of thing can go where. Their graph-based ranking algorithm, derived from TextRank, finds relevant documents without the blind spots of chunk-based RAG. Their logic engine controls generation, validates outputs, and enforces policy.

This matters beyond the technology itself. Local-first, sovereign AI — running on hardware you own, processing data that never leaves your control — is the only architecture that can meet the security and privacy requirements of government, defense, and regulated industries. Permion has demonstrated that this is not a theoretical possibility but a working reality.

They also won the G7 GovAI Grand Challenge. The problem set was cross-risk geopolitical analysis — a genuinely complex, open-ended problem. Their DSME application won for its explainability, auditability, and compliance. It is deployed on AWS GovCloud and the AWS classified cloud.

Sowa provided the philosophical foundation that makes the architecture coherent. He described Charles Peirce’s cycle of pragmatism: abduction proposes hypotheses, deduction evaluates them against an ontology, action tests them, induction incorporates what was learned into knowledge. This cycle — observe, orient, decide, act — is the fundamental pattern of intelligence. Any system that skips the deduction step cannot be trusted.

For a moment, it seemed complete. Here was a company with both the deep understanding and the engineering to build trustworthy AI.

...

3. The Structural Inheritance

But the engineering and the architecture are two different layers.

Permion uses Common Logic — ISO 24707 — as its representational foundation. Common Logic is a standard for exchanging first-order logic expressions. It is flexible. Any domain expert can define any relation their field requires. In medicine, you can define has_contraindication. In law, statutory_precedence. In aerospace, is_aerodynamically_coupled_with. The predicate vocabulary is open.

This flexibility is a real strength for a single organization. It allows domain experts to express knowledge in whatever terms are natural to their field.

The architecture also uses conceptual graphs, where relations are edges between concept nodes. Subject-predicate-object. The predicate is the connecting edge. This is the standard approach. It is well-understood and widely deployed.

But Common Logic is an open-predicate system. So is RDF. So is OWL. The Semantic Web was built on this same open-predicate foundation, and it failed at scale. Not because the technology was wrong. Because the cost of integration grows quadratically with the number of participants.

Consider two organizations. Organization A defines owes. Organization B defines has_contraindication. Integration requires one mapping. Three organizations require three mappings. Four require six. Ten require forty-five. One hundred require four thousand nine hundred and fifty.

This is the Babel Tax. It is not a theoretical risk. It is a demonstrated failure mode that the Semantic Web community documented over 25 years. The open-predicate model is structurally incapable of escaping it. Every new participant adds new predicates. Every new predicate requires new mappings. The cost compounds.

Permion’s architecture inherits this property because Common Logic, like RDF and OWL, allows any relation to be defined by any party. The demo runs on one machine. The architecture would face the same federation barrier that every open-predicate system has faced.

There is a second inherited weakness. In the edge-based model, an event like “Beethoven composed the Ninth Symphony in Vienna in 1824” becomes three separate fragments:

  • Beethoven composed Ninth Symphony.
  • Ninth Symphony was created in 1824.
  • Beethoven was in Vienna in 1824.

Each fragment is correct. None preserves the unity of the event. A query that asks “what was Beethoven doing in Vienna in 1824?” must reassemble the pieces. The event is not a first-class object. It is a reconstruction.

And there is a third. A verified fact and a provisional guess share the same structural form. Both are Common Logic statements. They are distinguished only by external policy, not by the structure of the claim itself. The demo showed the right behavior — the system refused to guess. But the architecture did not enforce it. The behavior was governed by policy, not by structure.

These are not flaws in Permion’s implementation. They are properties of the underlying standard. Permion’s engineers inherited them.

...

4. The Discovery

I found the Symbol Grounding Framework through a different path — not through the ontology community, but through the knowledge graph and reasoning community. It was not a product. It was a public-domain architecture, published at symbolgrounding.io, with reference code under Apache 2.0.

SGF starts from a different question than Permion does. Permion asks: how do we make inference fast on a single machine? SGF asks: how do we make meaning portable so that two systems that have never met can trust each other on first contact?

The answer was discovered through a process the author calls the qualification gauntlet. It works like this: propose a candidate structure. Subject it to adversarial tests designed to destroy it. If it can be eliminated, eliminate it. Keep only what survives.

The architect began with a hundred candidate semantic roles. Each was tested: could it be expressed as a combination of the others? If yes, it was eliminated. HAS_PURPOSE was eliminated — it is HAS_REASON with a specific frame. HAS_RESULT was eliminated — it is a changed HAS_PATIENT or a separate SynapseLink. HAS_VALUE was eliminated — it is a TypedLiteral or HAS_ATTRIBUTE.

The first pass killed forty. The second killed thirty more. When the dust settled, fifteen roles survived. They were not chosen. They could not be eliminated.

The same process was applied to binary relations. Five survived. To link types. Eight survived. To the verb vocabulary. One generic verb survived — RELATES_TO — with domain-specific relations expressed as concepts rather than primitives.

The result is a grammar of 33 primitives that is closed by construction. Vocabulary is infinite. The grammar is fixed. Integration cost becomes linear. The Babel Tax is not managed or reduced. It is structurally prevented.

But the architecture goes deeper.

Every claim carries an epistemic status from 7 tiers: CORE_DEFINITION, CONSTITUTIVE, SOURCED, CLAIMED, INFERRED, PROVISIONAL, GHOST. A verified fact from WordNet and a provisional guess from an LLM are structurally distinct. The reasoning engine treats them differently by construction, not by policy.

When a term cannot be grounded, SGF cannot guess. There is no mechanism for it. The grammar requires all Spokes to target grounded Canonical IDs or explicitly marked Ghosts. A Ghost node carries a provisional identifier and a GapReport. The system says “I don’t know” because it literally cannot produce a claim without a grounded target.

Below everything sits the Prime Registry. Approximately 65 semantic primes — SOMEONE, SOMETHING, DO, HAPPEN, MOVE, GOOD, BAD, THINK, KNOW, BEFORE, AFTER, HERE, NOW — serve as the bedrock. Every grounded concept must have a finite path down to one or more of these primes. This enables the Stranger Rule: two systems that have never met can understand each other on first contact because every term in an HFF packet can be traced back to shared primes.

Above it all sits Omega, a governance language that compiles policy into deterministic checks. UNKNOWN maps to HALT. The system halts rather than guessing.

Each mechanism exists because a simpler one failed. The open-predicate model failed at scale, so the grammar was closed. The edge-based model fragmented events, so the verb became the hub. The absence of epistemic tracking made facts indistinguishable from guesses, so the status hierarchy was built. The inability to say “I don’t know” allowed hallucinations to propagate, so the Ghost Protocol was created. The lack of a stopping rule for definitions allowed infinite regress, so the Prime Registry was established.

The architecture was not designed on a whiteboard. It was discovered by systematically eliminating everything that broke.

...

5. The Convergence

I went back to the 2024 video. Sowa said: “Without ontology, LLMs are clueless.”

I went back to the 2026 demo. Majumdar said: “LLMs are abduction machines. They create hypotheses.”

Then I looked at the SGF architecture.

Sowa said every output must be tested by deduction. SGF has an epistemic status hierarchy that structurally classifies every claim.

Sowa said reasoning is a cycle of abduction, deduction, induction, action. SGF has a Semantic CPU that walks a grounded graph in exactly this cycle.

Sowa said the system must refuse to guess when uncertain. SGF has a Ghost Protocol and a GapReport that make “I don’t know” a first-class output.

Majumdar showed twelve agents running under a logic engine that controls generation and refuses hallucination. SGF provides the wire protocol and governance language that let those same agents interoperate across organizational boundaries without the quadratic cost of the Babel Tax.

Two independent efforts. Different starting premises. Same structural conclusion.

What Sowa and Majumdar described What SGF provides LLMs are hypothesis generators that must be tested The Probabilistic Sandwich — LLMs propose, gates dispose Outputs must be verified against an ontology Epistemic status hierarchy, SOAM alignment, ProofTrace Reasoning is a cycle of abduction, deduction, induction, action Semantic CPU — deterministic kernel walking grounded graph Multiple agents must be orchestrated under logic HFF/AFP wire protocol for multi-agent coordination The system must refuse to answer when uncertain Ghost Protocol and GapReport An ontology must provide the criteria for truth Closed grammar, Prime Registry, Omega governance

The convergence is not a coincidence. The architecture is not one design among many. It is the shape that emerges when you eliminate everything that does not work.

...

6. The Complementarity

The two efforts are not in competition. They operate at different layers.

Permion’s inference engine is a breakthrough in local-first, multi-agent AI. Twelve agents on a laptop with no GPU. Disk streaming that makes models larger than RAM runnable in real time. A logic engine that refuses to guess. These are genuine achievements.

SGF’s closed grammar prevents the Babel Tax that has crippled every open-predicate system at scale. Its epistemic hierarchy makes the trustworthiness of every claim structurally explicit. Its Ghost Protocol ensures the system cannot guess. Its Stranger Rule enables federation on first contact. Its governance language compiles policy into deterministic checks.

One builds the engine. The other builds the chassis, the steering, and the brakes.

Permion could implement SGF on their XVM. The closed grammar would eliminate the quadratic integration cost. The epistemic hierarchy would make claim trustworthiness structural. The Ghost Protocol would make “I don’t know” an architectural invariant. The Stranger Rule would enable their multi-agent systems to federate across organizational boundaries on first contact.

SGF is public domain. Anyone can implement it. Including Permion.

...

7. What This Means

For AI architects building the next generation of multi-agent systems. The question is no longer whether a closed grammar, an epistemic hierarchy, a gap protocol, and a prime registry are architecturally necessary. The convergence proves they are. The open standard exists at symbolgrounding.io. You can implement it today.

For knowledge graph engineers who have lived through the Babel Tax. The open-predicate model has been the bottleneck for thirty years. SGF’s closed grammar eliminates the quadratic integration cost. Vocabulary is infinite. Grammar is fixed. Integration cost is linear. The architecture exists today.

For venture capitalists looking for the next infrastructure wave. The market for trustworthy AI coordination is larger than the market for AI inference. The convergence proves the architecture is necessary. The specification is open. The opportunity is in the implementation layer.

For ontologists and knowledge representation researchers. Sowa’s pragmatic cycle has been validated by independent discovery. The fifteen semantic roles are the universal joints of machine meaning. The convergence is evidence that the field is converging on a structural consensus.

For Permion. Your inference engine is a breakthrough. The engineering is real. The architectural layer that makes it scale across organizational boundaries is available now, in the public domain, ready to implement.

...

8. The Invitation

The architecture for trustworthy AI was not designed in a boardroom. It was discovered by elimination. Two independent teams, starting from different premises, arrived at the same structural conclusion. That convergence is evidence that the architecture is necessary, not optional.

Permion built the fastest local-first inference engine in production. Twelve agents. No GPU. Nine thousand tokens per second. The G7 winner.

SGF provides the semantic substrate that makes that engine scalable across organisational boundaries without the Babel Tax.

One builds the machine. The other preserves the meaning.

The code is in the public domain. The specifications are published. The bridge between them has not been built yet.

The blueprints are on the table. The engine is running. The question is no longer whether this architecture works. The question is who will build the integration layer first.

That answer will define the next decade of trustworthy machine intelligence.

...

Learn more about SGF

By , No comments:
Tags , ,
Subscribe to: Posts (Atom)