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 about Permion, its architecture and some options.
Resources
- https://medium.com/@JamesStakelum/the-architecture-that-makes-ai-trustworthy-wasnt-invented-it-was-discovered-7db897138b21
- https://ontologforum.com/index.php/ConferenceCall_2026_06_03
- https://www.youtube.com/watch?v=oy-uzJuSr70
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
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
- You can learn more about SGF on its GitHub repository: https://github.com/SymbolGroundingFramework/SGF-manifest
- RFC specifications: https://github.com/SymbolGroundingFramework/SGF-manifest/tree/main/specs
- The six‑volume SGF book series: https://www.amazon.com/dp/B0H3FGSPK6
