Why Ontology Is the Semantic Operating System for Large‑Model AI

Recent enterprise deployments of large language models encounter hallucinations, logical mismatches, and misaligned outcomes because models lack a unified, computable, and evolvable semantic structure.

Re‑examining Knowledge Engineering

Richard Sutton’s The Bitter Lesson argues that lasting progress comes from methods that scale with compute—search and learning—rather than from manually curated knowledge bases that are costly to maintain. The lesson does not dismiss knowledge itself, but warns against high‑cost, static knowledge injection that hinders continuous scaling. In high‑risk domains such as law, medicine, finance, and government, large models still produce hallucinations, logical, numerical, and temporal errors.

Ontology as the AI Semantic Operating System

Ontology is presented as a runnable semantic system that manages concepts, relationships, constraints, roles, events, and actions. It transforms textual business objects (e.g., customers, contracts, risks) into machine‑understandable units, providing “skeleton and guardrail” semantics that stabilize business structures and constrain critical actions. Models handle perception and generation; ontologies define semantic boundaries, enabling AI to move from conversation to execution.

Six Core Conclusions from the Discussion

Enterprise‑wide inconsistency in describing the same thing stems from a missing shared semantic foundation, not from insufficient data.

Without a unified semantic base, large models and agents cannot operate reliably in business scenarios.

Static data‑warehouse schemas cannot keep pace with continuously evolving business realities; semantic‑enhanced programmable graphs (LPG/SPG) naturally absorb change.

Ontologies must evolve from descriptive artifacts to actionable infrastructures that support actions.

In the AI era, ontologies can become a private moat, preserving proprietary business logic as generic models improve.

Delaying semantic‑layer development risks missing the window of opportunity, as community momentum may wane.

Two Emerging Paths for Enterprise‑Level Agents

Practitioners observe two representative deployment patterns:

Ontology‑first (exemplified by Palantir): build a stable, auditable semantic skeleton before layering models.

Model‑first (exemplified by Claude‑related efforts): start with a base model and augment it with a context graph for external knowledge, tool invocation, and workflow orchestration.

The most competitive agents are expected to fuse both approaches, using ontologies for deterministic constraints and models for creative reasoning.

Organizational Realities that Hinder Progress

The discussion identified three intertwined obstacles:

Insufficient business‑driven motivation: departments prioritize immediate data extraction over long‑term semantic alignment.

High cross‑department coordination costs: concept, data, and responsibility boundaries often coincide with organizational silos, making alignment a coordination problem.

Unclear ROI: benefits of ontologies—consistency, reusability, extensibility—are implicit and delayed, making budgeting decisions difficult.

Additional factors include talent scarcity (people who understand business, data, semantics, and AI) and outdated engineering paradigms (static, one‑off modeling).

OpenKG Practice Insights

OpenKG demonstrates a modern knowledge infrastructure:

SPG (Semantic‑enhanced Programmable Graph) unifies data, semantics, rules, and actions into an evolvable graph, allowing the ontology to serve as a live semantic layer rather than a static definition.

KAG (Knowledge‑Augmented Generation) couples structured knowledge with large‑model inference, guiding retrieval, decomposition, and solving to mitigate RAG’s temporal, referential, and logical distortions.

SkillNet abstracts knowledge into reusable skill units, moving from “knowing what” to “knowing how” for fine‑grained task execution.

MemOS provides a memory operating system for long‑term retention, continual learning, and self‑update, enabling agents to manage long‑term memory and evolve over time.

Together these components form a chain from semantic modeling to execution.

Technical Stack References

Semantic engine: https://github.com/OpenSPG/KAG-Thinker

Memory core: https://github.com/MemTensor/MemOS

Skill repository: https://skillnet.openkg.cn