Boldsea Framework: Executable Ontologies

Updated 26 November 2025

Boldsea Framework is a subject-event ontology platform that fuses declarative semantic modeling with event-driven dataflow execution to model complex, dynamic, distributed systems.
It employs the Boldsea Semantic Language to define models with runtime constraints and causal transparency, enabling live system evolution without downtime.
Its architecture uses an immutable, append‐only event graph to ensure explicit causality, multiperspectivity, and efficient auditability across varied applications.

The Boldsea Framework is a subject-event ontology and executable ontology platform for modeling complex dynamic, distributed, and multiperspective systems. It fuses declarative semantic modeling with event-driven dataflow execution. Boldsea directly interprets semantic models—defined in the domain-specific Boldsea Semantic Language (BSL)—as active entities within an immutable temporal event graph. The framework enforces all model constraints at runtime, provides inherent temporal and causal transparency, and enables live process evolution without system downtime. Boldsea’s architecture has been demonstrated as an alternative to imperative platforms (BPM, FSM, BT), offering unified data and logic representation, distributed execution without reliance on global time, and a formal foundation grounded in explicit causality and epistemic filtering (Boldachev, 11 Sep 2025, Boldachev, 20 Oct 2025, Boldachev, 19 Nov 2025).

1. Core Principles: Subject-Event Ontology and Executable Semantics

Boldsea proceeds from four first-class concepts: Subjects, Events, Models, and the Dataflow Engine.

Subjects are the actors (human, service, sensor, agent) responsible for asserting events. Every event encodes subject provenance.
Events are atomic fixations: immutable records with id, actor, optional role, key (model_id, context), payload (structured data), and explicit causal references (refs). Each event’s inclusion in the global History H makes its payload immediately available for computation (“existence-for-system”).
Models are “epistemic filters,” defining the concepts, data schema, permissions, and preconditions that gate which events a given subject/actor can assert. Models are not merely passive schemas but drive validation and execution logic.
Declarative Dataflow Engine processes H as a growing, append-only event DAG. Guards (explicit Conditions) defined in the models are evaluated against H. When satisfied, new events are emitted, referencing their causes.

Causality is formalized as the transitive closure (hb) of refs, with history monotonic (I1), causal graphs acyclic (I2), and every event's causal ancestry fully traceable (I3). Boldsea diverges from legacy BPM and ontology systems by rendering all semantics executable and maintaining complete, immutable, temporally ordered event graphs (Boldachev, 11 Sep 2025, Boldachev, 20 Oct 2025).

2. The Boldsea Semantic Language (BSL): Syntax, Semantics, and Stratified Logic

BSL is a domain-specific declarative language for modeling executable ontologies. It provides constructs both for ontology/schema definitions and for runtime event/dataflow guards.

Model Syntax (selected BNF):

model_definition declares concept/action models.
property_list enumerates Attributes, Relations, Roles, and SetDo operations.
restriction_block assigns Conditions, SetValue (derived values), permissions, and additional constraints.

Restriction Expressions:

JavaScript-like formulae and graph-pattern queries (\$and \$\$ prefixes), operating on the temporal event DAG.

Formal Logic Core:

Based on first-order logic with stratified negation (negation only on atomic predicates), ensuring fixpoint convergence of the event derivation operator.
Built-in literals: Exists, Count, ExistsMax, Order—expressing pattern membership, counting, maximality under hb, event order.

Axiomatization:

Causality and Nesting: Events are hierarchically nested and causally linked; events at nesting level n require prior existence of parent event at n-1.
Execution Condition: An event model fires (“becomes enabled”) once all dependencies (“prerequisite events”) are satisfied and its logical condition holds.
Event Generation: Firing creates a new reification event at the next time instant, with payload computed by SetValue (if present).

Axioms A1–A9 (from (Boldachev, 20 Oct 2025)) underpin history monotonicity, acyclicity, last-write-wins, explicit model-based validation, multiperspectivity, and correction by addition of events (not mutation).

3. Engine Architecture and Event-Driven Dataflow Execution

Boldsea’s runtime is an interpreter for the event graph semantics encoded in BSL models. The principal architectural modules (following (Boldachev, 11 Sep 2025, Boldachev, 19 Nov 2025)) are:

Component	Function	Notes
Event Graph Store	Append-only DAG for all events	Full order, causal ancestry, actor/model provenance
Dataflow Engine	Executes event-driven model restrictions	Evaluates and triggers Condition, SetValue, SetDo rules
Model Repository	Stores versioned, executable ontologies	Supports live edits as graph events
UI/IDE Layer	Model/restriction editors, graph viewers	Forms/UI auto-generated from models
View-Controller	Binds model events to interface updates	Direct rendering from semantic event state
Validation/Admission	Runtime enforcement of schema, permissions	Guards append, never mutate, the event log
System Controller	Executes SetDo operations as system acts	E.g., microservice calls, robot action dispatch

Dataflow is represented as propagating tokens (reification events) through nodes (model events) as their subscriptions (Condition rules) become satisfied. Reactivity is achieved via triggers: only those rules referencing affected properties are evaluated upon new events. Polling is never used; propagation is entirely event-driven.

Auto_chain ensures per-actor/context total orderings for last-write-wins scenarios. All model updates, system actions, and user interactions are themselves first-class events, enabling zero-downtime model evolution and full auditability.

4. Formal Properties: Causality, History, and Multiperspectivity

Explicit causal references (“refs”) serve as the only source of happens-before (hb) order, precluding reliance on wall-clock timestamps for event sequencing. The principal properties are:

Monotonicity (I1): History only grows; no erasure or mutation of past events.
Acyclicity (I2): The causal graph is a DAG (no cycles in hb).
Traceability (I3): Each event’s full causal cone is recoverable by refs traversal.

Multiperspectivity (A4): Disagreement and corrections are modeled as additional events rather than mutations. The event history can contain conflicting assertions for the same model/context from different subjects, with subsequent events providing refuted or superseding assertions as required. Presumption-of-truth (A5) means event payloads are considered computational fact upon emission, with corrections handled by appended refutation events (A6). Partitioning by (model_id, context) enables sharded, concurrent processing in distributed scenarios.

5. Runtime Model Modification, Temporal Transparency, and Fusion of Logic and Data

Boldsea supports live addition, replacement, and removal of models and restrictions at runtime:

Live Model Editing: All model changes are events in the same history graph. The engine reconciles subscriptions accordingly, maintaining reactive operation without interruption.
Two-Level Event Structure: Model events define executable constraints; reification events are instance-level facts validated by model logic. This directly unifies TBox/ABox metaphors.
Immutable Temporal Graph: All events (including model edits) are immutable and cryptographically chained; replay and forensics are inherent.
Logic-Data Fusion: Queries in Conditions/SetValue/SetDo natively access the temporal event graph. There is no external rule engine or separate business logic layer—control and data are seamlessly coexistent.

Temporal transparency means the complete model, instance data, and process logic can be replayed or audited at any point, reconstructing system evolution deterministically (Boldachev, 11 Sep 2025, Boldachev, 19 Nov 2025).

6. Practical Applications and Empirical Evaluation

Robotic Control

Empirical studies in robotic domains compare Behavior Trees (BT) with Boldsea-style Executable Ontologies (EO). For a “Delivery + Recharging + Docking” task, EO required fewer elements (8 model events vs. 14 BT nodes), permitted runtime model updates without restart, and provided native auditability and traceability. Reactivity in EO was governed by propagation through affected rule subscriptions, exhibiting significantly lower update latency and CPU usage for sparse updates. Semantic transparency and runtime extensibility were highlighted as strengths; limitations include higher cognitive entry requirements and less mature ecosystem (Boldachev, 19 Nov 2025).

Enterprise and Distributed Workflow

Use cases include microservice workflows and DLT integration (e.g., payment processing across Payment, Risk, and Settlement services). Each domain actor emits events conforming to its Model; guards trigger new events (risk checks, settlements) based on declarative conditions. All causal relationships are explicit, enabling audit and compliance; sharding by context or service supports inherent scalability. DLT backends (permissioned blockchain) are used for tamper-proof event log storage, with the causal DAG verifiable on-chain (Boldachev, 20 Oct 2025).

Business Process Modeling

Replacing rigid control-flow with declaratively specified event models (see “ProcessingRequest” example), Boldsea enables fine-grained permissioning, derived value computation, and complex conditional flows, all while supporting live schema evolution and full process visibility (Boldachev, 11 Sep 2025).

7. Summary and Ongoing Directions

Boldsea constitutes a mathematically grounded event-ontology framework, free of global clocks and external process engines, unifying models, data, and runtime logic in a single event DAG. Its design enables:

Zero-downtime, no-code model/process adaptation
Tamper-evident, order-preserving causal histories
Native support for distributed, multiperspective, and audited domains
Semantic fusion of schema and executable process definitions

Active research focuses on performance at scale, decentralized (P2P) deployment, and tighter LLM integration to automate model construction and to exploit the event graph as a foundation for persistent semantic memory (Boldachev, 11 Sep 2025, Boldachev, 20 Oct 2025).