Ontology Intelligence & Decision Modeling: From OntoGraph DB to OntoOS (WorldOS)

Enterprise data architectures and the limits of graph databases

Relational databases, data warehouses, search engines and message queues have each addressed a slice of enterprise data needs. In complex domains such as supply‑chain, equipment maintenance, city governance and risk control, the missing piece is semantic meaning of relationships. Traditional graph databases can store nodes, edges and properties, but they cannot represent the business meaning of a connection nor derive higher‑level attributes automatically.

Graph database vs. ontology database

Core problem : graph DB records what relationships exist ; ontology DB records what the world structure is and how it changes .

Data model : graph DB = node + edge + properties; ontology DB = entity types + relationship types + semantic attributes + rules.

Computation : graph DB supports traversal and path queries; ontology DB supports attribute derivation, cross‑entity propagation and causal tracing.

Typical scenarios : graph DB – social graphs, recommendation; ontology DB – supply‑chain inference, equipment risk propagation, operational decision making.

Explainability : graph DB – weak; ontology DB – strong (each value can answer “why”).

Illustrative example

Pump P01 temperature 105°C
  → Well W01 riskLevel 95
    → Region R01 alertLevel 95

A graph DB can show that P01 is linked to W01, but it cannot automatically compute riskLevel or alertLevel, nor explain that the alert results from a Max aggregation of the temperatures of P01 and P02. Ontology‑driven intelligent applications require exactly those derived values.

OntoGraph – the state layer

OntoGraph (formerly AbutionGraph) stores the current world state with:

Structured storage of entities and edges.

Aggregated attribute semantics such as Agg.Last() and Agg.Sum().

Native spatio‑temporal, geographic and vector search.

Graph‑level security: view control, permissions, masking and expiration policies.

Developers define ontology schemas and write state data via a chainable API:

// Define ontology schema: Pump, Well, Region...
Dimension.label("PUMP", "Pump")
    .property("temperature", Double, Agg.Last(), "°C")
    .build();

// Write world state
graph.addKnow(
    Knowledge.labelV("PUMP").vertex("P01")
        .property("temperature", 105.0)
        .build()
).exec();

// Query: from a pump, find associated well and its risk level
graph.V("P01").InE().label("PUMP_WELL")
    .InV().label("WELL")
    .selectProps("riskLevel")
    .ToList().exec();

These APIs answer “what the world is now”. The next layer explains “why it is so”.

Property Runtime – making the world compute itself

Version 4 of OntoGraph introduces a Computed Property engine comparable to Palantir Foundry. Two computation categories are unified under a single propagation chain:

Intra‑entity derivation : coverageDays = inventory / dailyDemand Cross‑entity propagation : Pump.temperature → Well.riskLevel → Region.alertLevel Previously these rules lived in disparate systems; now they are expressed via PropagationRule configurations, replacing hand‑written action functions.

Example configuration (user‑side, core engine omitted):

// KPI derivation: inventory coverage days
PropagationRule.intraEntity("GOODS", "inventory")
    .target("GOODS", "coverageDays")
    .formula(D.expr("inventory/(dailyDemand?:1)", "inventory", "dailyDemand"));

// Cross‑entity propagation: pump temperature → well risk level (max aggregation)
PropagationRule.crossEntity("PUMP", "temperature")
    .target("WELL", "riskLevel")
    .traversal(D.reverseTraverse("PUMP_WELL").targetLabel("WELL"))
    .formula(D.agg(Agg.Max()));

Expressions support arithmetic, comparisons, ternary logic and null handling, allowing business users to configure calculations.

Lineage tracking

WHY (causal chain) : which entities/rules participated – used for audit and compliance.

HOW MUCH (drift) : how much the value changed from the previous run – used for KPI trend and anomaly detection.

WHAT (input snapshot) : exact input values at computation time – used for fault reconstruction.

When Region.alertLevel jumps from 82.5 to 95, the system can instantly trace the chain back to the two pumps whose temperatures triggered the Max aggregation:

Region R01 . alertLevel = 95
  ← Field F01.productionRisk = 82.5
    ← Well W01.riskLevel = 95
      ← Pump P01.temperature = 105, Pump P02.temperature = 70
        Rule: Max aggregation

Four‑layer ontology model

┌───────────────────────┐
│ State   – OntoGraph    │  // Current world state
└───────────────────────┘
        ↓ attribute change triggers
┌───────────────────────┐
│ Causality – Property Runtime │ // Why the state has those values
└───────────────────────┘
        ↓ decision basis
┌───────────────────────┐
│ Intent – World Runtime / ActionPlan │ // What should be done
└───────────────────────┘
        ↓ intent execution
┌───────────────────────┐
│ Execution – ActionExecution │ // Actual effect
└───────────────────────┘

Version 4.4 adds a DecisionProperty layer that semantically declares decision‑related attributes, protects them from direct overwrites and guarantees causal integrity.

OntoFlow – development platform for ontology‑intelligent apps

OntoStudio : visual ontology modeling workspace.

AbutionQL : chainable query language for KPI aggregation and graph traversal.

ActionFunction : condition‑triggered intent declarations.

Graph‑level security : view control ( __vis__), role permissions, field masking.

AI‑assisted development : LLM‑generated ontology and query code via AbutionGraphSkill.

Typical development flow:

// KPI aggregation: average risk level of all wells
graph.V().label("WELL")
    .AggregateProps(row => row.get("riskLevel", Agg.Avg()), "riskLevel")
    .exec();

// Action function: declare procurement intent when risk exceeds threshold
ActionFunction procurement = new ActionFunction() {
    public boolean condition(Entity e, Context ctx) {
        return (Double) e.getProperty("riskLevel") > 90;
    }
    public ActionPlan apply(Entity e, Context ctx) {
        // execute intent
    }
};

OntoFlow strings together "ontology modeling → rule configuration → query analysis → decision action" as a seamless pipeline.

OntoOS – parallel‑world simulation sandbox

OntoOS (WorldOS) answers the question “What would happen if we did X?” by providing:

Trusted baseline cloning from production graphs with fingerprinted reports.

Tick‑driven world evolution supporting transactional rollbacks.

Independent rule sets (e.g., sandbox‑v2) for sandbox vs. production.

Scenario comparison across parallel projects aligned by tick.

End‑to‑end traceability across State → Causality → Intent → Execution.

Data, rule and lineage isolation ensure sandbox experiments never affect the stable production world.

Production world (OntoGraph)      Simulation world (graph copy)
───────────────────────        ───────────────────────────────
Real‑time sensor writes          Tick‑batch state evolution
500 ms flush propagation         Tick‑boundary flush
PropertyLineageCore             PropertyLineageCore (independent store)
+ PropertyInputTrace             + StateSnapshot (reconstructed per tick)

Why this is not just another graph database

Both store entities and relationships (✅).

Only OntoOS provides automatic attribute derivation and propagation (✅ vs ❌).

Only OntoOS records cross‑entity causal chains (✅ vs ❌).

Only OntoOS declares decision semantics and protects them from direct overwrite (✅ vs ❌).

Only OntoOS separates intent declaration from execution (✅ vs ❌).

Only OntoOS supports parallel‑world simulation and comparison (✅ vs ❌).

Only OntoOS manages rule versioning independently (✅ vs ❌).

Graph‑level security (view, permission, masking, expiration) is fully integrated (✅).

Thus a graph database is infrastructure; the combination of ontology database, Property Runtime and World Runtime forms an operating system for intelligent applications.

Conclusion

Digital transformation’s next step is not to load more data into a graph database but to enable systems to understand the structure and change laws of the business world. OntoGraph stores the state, Property Runtime makes the world compute and explain itself, OntoFlow accelerates application development, and OntoOS lets decision makers preview future outcomes in a sandbox.