Boldsea Engine: Ontology-Driven Workflow

• Boldsea Engine is an event-driven system that formalizes subject-event ontologies with deterministic, acyclic causal graphs.
• It employs an append-only event store, unified model repository, and BSL-based guard evaluation for model-driven event validation.
• The engine supports multiperspectivity in distributed asynchronous domains, with applications in microservices, DLT, IoT, and collaborative editing.

The Boldsea Engine is an event-driven workflow and ontology execution system that realizes a formal subject-event ontology without reliance on global time. It interprets subjectively fixed events through epistemically constrained models and deterministic dataflow, ensuring monotonic, acyclic causal histories for distributed, asynchronous, and multiperspective domains. The foundational principles and execution architecture are detailed in (Boldachev, 20 Oct 2025) and (Boldachev, 11 Sep 2025), establishing both the theoretical and practical semantics of executable ontologies in the Boldsea framework.

1. Formal Foundations: Subject-Event Ontology and Causality

The Boldsea Engine operationalizes a subject-event ontology predicated on the concept of event fixation by epistemic subjects (actors). An event is formalized as an atomic act of discernment by a subject, subject to the epistemic constraints of a reference model. Formally, an event is represented as

$$\text{Event} \coloneqq \{ \text{id} : \text{ID},\; \text{actor} : \text{Actor},\; \text{role}? : \text{Role},\; \text{key} : \text{Key},\; \text{payload} : \text{Payload},\; \text{refs}? : \mathrm{Set}(\text{EventID}) \}$$

with $\text{Key} := \text{ModelID} \times \text{Context}$ partitioning event history $H$ into independent channels $H_k$. Models function as epistemic filters, defining which events can be fixed based on schema, permissions, and conditionality. The core causal order is established not by timestamps but by the transitive closure of explicit references:

$\text{hb} := \mathrm{tc}(\mathrm{refs})$

where the "happens-before" relation arises only from the explicit causal graph, ensuring acyclicity and traceability without global clocks (Boldachev, 20 Oct 2025).

2. Engine Architecture and Execution Semantics

The engine maintains an append-only event store and a unified model repository, forming the backbone of the execution semantics. Major components include:

• Event Store: Append-only, partitioned by keys.
• Model Repository: Stores models with schema, permissions, and conditions.
• Guard Engine: Evaluates Boldsea Semantic Language (BSL) guards over the current history.
• Auto-chain Module: Automates W3 (actor-serial per key) by chaining new events to the last write per actor/key.
• Batch Reactor: The core dataflow driver implementing the snapshot–batch–fixpoint workflow ($F(H)$).
• Admission Controller: Enforces model-based generation (A9) via two-phase event admission logic.

The execution loop is as follows:

1. Take a snapshot of $H$.
2. For each guard $Y$, if condition $G_Y$ holds and all candidate events emitted by $\mathrm{emit}_Y(H)$ pass admission, construct new events $\text{Key} := \text{ModelID} \times \text{Context}$0, generate their references, and append to $\text{Key} := \text{ModelID} \times \text{Context}$1.
3. Repeat until a fixpoint $\text{Key} := \text{ModelID} \times \text{Context}$2 is reached (no guard fires).

Formally:

$\text{Key} := \text{ModelID} \times \text{Context}$3

$\text{Key} := \text{ModelID} \times \text{Context}$4

Each new event $\text{Key} := \text{ModelID} \times \text{Context}$5 obtains references from explicit, auto-chain, and base mechanisms (Boldachev, 20 Oct 2025).

3. Axioms, Invariants, and Determinism Guarantees

Boldsea enforces nine axioms (A1–A9) and three invariants (I1–I3):

• A1: Event existence from fixation, not external verification.
• A2: Causality defined only by explicit references.
• A3: No unlisted causes.
• A4: Multiperspectivity—conflicting branches can coexist.
• A5: Presumption-of-truth—events are usable immediately.
• A6: Corrections/refutations only via new events; no deletion.
• A7: Last-Write-Wins per actor/key, determined by the $\text{Key} := \text{ModelID} \times \text{Context}$6-maximal event.
• A8: Partitioning history by key ($\text{Key} := \text{ModelID} \times \text{Context}$7).
• A9: Model-based event validation—existence of a model, permission, valid payload, and all existential predicates witnessed in refs.

The invariants are:

• I1: Monotonicity (append-only, no deletion).
• I2: Acyclicity of $\text{Key} := \text{ModelID} \times \text{Context}$8.
• I3: Full traceability (finite, reconstructible causal cones).

Deterministic execution is guaranteed by stratified negation, finiteness of guards, and monotonic, acyclic $\text{Key} := \text{ModelID} \times \text{Context}$9. The existence of a least fixed point for $H$0 is proved constructively (Boldachev, 20 Oct 2025).

4. Declarative Programming with Boldsea Semantic Language (BSL)

BSL is a model-driven domain-specific language rooted in first-order logic with temporal extensions. The mini-grammar includes formulae such as

$H$1

where atomic predicates include type-tests, field equalities, existential quantification, and order relations (“Order($H$2 BEFORE $H$3)”). A typical guard in BSL could be:

$H$4

with an emission constructing a new "exec" event. Event validation and actor authorization are declaratively enforced through the "admit_incoming" predicate, guaranteeing A9 at runtime (Boldachev, 20 Oct 2025, Boldachev, 11 Sep 2025).

5. Event Validation, Causal Chains, and Model-Based Admission

Admissibility of new events is governed by model-based validation (A9) and causal chaining (W3). For any event $H$5:

• Event Admission: There must exist a model $H$6 such that $H$7, the actor is authorized, the payload is schema-valid, and existential predicates in $H$8 are witnessed in refs.
• Auto-chain: For every actor $H$9 and key $H_k$0, new events are chained to the $H_k$1-maximal prior event by $H_k$2 on $H_k$3, ensuring per-actor serializability.

These mechanisms ensure all formal properties at runtime. Table 1 summarizes the event admission process.

Step	Description	Formal Condition
Model match	Event references existing model	$H_k$4
Actor authorized	Actor meets Permission(M)	$H_k$5
Payload validated	Payload passes schema(M)	$H_k$6
Causal witnesses	Witnesses satisfy existential predicates	$H_k$7

6. Dataflow Execution and Unification of Data and Logic

Model events act as dataflow operators, while reification events serve as data tokens. The semantic store integrates both models and events, so that process execution, business logic, and ontology are always consistent. Dataflow execution is subscription-driven: model events subscribe to classes of prior events and fire declaratively via condition satisfaction. There is no compilation—the engine interprets BSL directly over the event graph, with model modification immediately reflected in engine behavior. The system provides full temporal transparency: every system state at any time $H_k$8 is reconstructible from event history up to $H_k$9 (Boldachev, 11 Sep 2025).

7. Application Scenarios and Domain Fit

Boldsea is demonstrated in multiple workflow and ontology contexts, including:

• Microservice Orchestration: Each microservice acts as a subject, models constrain schema and permissions, and guards drive inter-service automation. All causality is purely graph-based, not time-based.
• DLT-Style Ledgers: Events capture asset transfers, UTXO dependencies are modeled as refs, and the causal graph itself is the ledger.
• IoT Sensor Networks: Actor roles, value ranges, and anomaly detection use models and guards to automate alerting.
• Collaborative Editing with Multiperspectivity: Each editor's changes are distinct branches; resolution is policy-driven via new merge events, not forced by the engine.

In all domains, causal order is established with $\text{hb} := \mathrm{tc}(\mathrm{refs})$0—never by timestamp. Fixation, validation, and multiperspectivity accommodate distributed, asynchronous, and conflicting observations natively (Boldachev, 20 Oct 2025, Boldachev, 11 Sep 2025).

---

In summary, the Boldsea Engine provides a deterministic, formally grounded platform for ontology-driven workflow execution, unifying event data and declarative business logic in an append-only, causally ordered store. Its semantics and system architecture support high assurance in correctness, multiperspectivity, and transparent process automation for distributed and complex system domains.