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

• https://medium.com/@JamesStakelum/what-is-sgf-18d9ae55cf3d
• https://github.com/SymbolGroundingFramework/SGF-manifest/blob/main/essays/SGF_WHITE_PAPER.pdf

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:

• Markdown: https://github.com/SymbolGroundingFramework/SGF-manifest/blob/main/essays/SGF_WHITE_PAPER.md
• PDF: https://github.com/SymbolGroundingFramework/SGF-manifest/blob/main/essays/SGF_WHITE_PAPER.pdf

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.