Architecture
This is the curated map of the architecture/ tree (37 pages). It groups every page by what it's
actually about — the commit model, the analytics/reasoning plane, distribution and scaling,
performance, media/voice/visualization, the robotics/GPU tail, and security/access hardening — so
you can go straight to the layer you need instead of scanning a flat file list. Pages marked
★ are the release-defining contract pages tracked directly in site navigation and by the
documentation-contract gate (scripts/check_documentation_contract.py); everything else here is
just as real, only demoted out of the sidebar.
For the engine's single guiding design principle, see
North Star: Seamless — every cross-modal read/write path (a write that
touches OWL, vector, graph, and time-series together) is implemented at every wire surface
(RPC, every SQL wire, SPARQL, GraphQL, …), never merely flagged at the one it was first built for.
Core commit & governance model
The transactional backbone: one durable commit point, one structural property schema, one served
modality identity, and the substrate they all sit on.
| Page |
What it covers |
| The master-of-all engine |
The deep architectural reference: durability, cross-modal ACID, RDF/OWL mapping, the RLS request path, streaming/CDC, federation, multi-Raft + cross-shard 2PC, tenant lifecycle. |
| ★ Verified Request Authority |
The eg2. request envelope every call carries — request id, graph, method, digest, timestamp, nonce, idempotency key, ACL agent, tenant, audience, policy version, roles, scopes, delegation chain, trace context. |
| ★ Authoritative MutationBatch |
The engine's durable mutation currency — commit-before-ack staging, durable idempotency/status, ordered projection outbox, the native WorkItem state machine. |
| ★ Governed ChangeEnvelope |
One native transaction for external graph/object material, policy, lineage, evidence, typed content versions/cursors, and the outbox. |
| ★ Canonical structural properties |
Why structural meaning uses one key per concept — property blobs are open MessagePack, but structural fields aren't silently promoted through aliases. |
| ★ Governed modality serving |
Universal Artifact/Occurrence/Rendition/Segment/Feature/EvidenceLocus identities, the ServedModality ingest/query/lifecycle service, and the one cursor-driven KnowledgeStream protocol shared by every modality. |
| Subsystems (C4 containers) |
How the broker, observability stack, KV-cache, and every wire adapter compose on the one GraphCore + redb-authoritative store + unified RowSet planner. |
| One build, opt-in layers |
The feature-composition map: the one main full-featured build plus the opt-in cluster (HA Raft) and full-extras (GPU/ROS2) layers. |
| Epistemic OS Hardening — capability catalog |
The code-verified, line-anchored catalog of everything the hardening program (Phase 0 → Phase 3 + "exceed" tracks) shipped. |
Analytics, reasoning & optimization
The numeric/analytics kernel, the incremental-reasoning plane, and self-improving program
optimization.
| Page |
What it covers |
| ★ Analytics Program — one kernel, two surfaces |
The BLAS/LAPACK-free Rust numeric kernel (eg-numeric) that serves both Python-side array math and in-database analytics over engine-resident data. |
| ★ Numeric kernel |
The kernel foundation of the Analytics Program — compiled kernel, Agent Utilities numeric surface, and native engine operators. |
| ★ Distributed analytics & incremental reasoning |
Verified coordinator RPCs for leased/fenced remote workers, durable typed results, and outbox/cursor-driven TMS, conflict, causal, and materialization maintenance. |
| ★ Native program optimization |
The submit_program_optimization contract, 13 Rust-native optimizer families, evidence across all 14 modalities, governed runtime plan steps, evaluation-gated promotion. |
| Lakehouse LTAP interop |
The LTAP (Lakehouse-Transactional-Analytical Processing) superset: external engines read the store as open Parquet + Delta/Iceberg with zero ETL. |
| Data mining |
graph_mine / /api/mining — pattern and structure mining over engine-resident graphs. |
| Graph learning |
graph_learn / /api/graphlearn — learned representations over the same substrate. |
| Analytics in UQL (EG-353) |
Analytics operators reachable directly from the Unified Query Language. |
Distribution & scaling
Raft clustering, resharding, admission control, and the correctness harness that gates every
distributed/durability claim.
| Page |
What it covers |
| Native ASR provider (GOC-33) |
Native Rust speech-to-text, reachable over the engine's own wire protocol as Method::Asr. |
| Native Piper-ONNX TTS (GOC-34) |
The native text-to-speech provider behind the tts.* wire contract. |
| Native visualization (D-VZ-1) |
The LOD-native visualization stack (declarative chart IR, columnar store, decimation/density kernels) in place of a matplotlib-style library. |
| Remote KV-cache HTTP backend |
The kvcache-server feature exposing the shared, content-addressed KV-cache backend so parallel vLLM/LMCache instances share blocks by token-hash. |
Robotics, GPU & the distribution tail
Security, access & hardening
| Page |
What it covers |
| RBAC action unification — Phase 1 |
Blast-radius map for unifying two RBAC action vocabularies. Phase 1 verdict: not yet safe to fully unify; no behavior changed by the document itself. |
| Native capacity & WorkItem admission authority |
The additive native protocol for the GOC-21 capacity lease and GOC-19 WorkItem submit surfaces; the engine's redb tables are authoritative, schedulers are projections. |
Design principle: design for a network boundary
Every out-of-process invocation crosses a process boundary — serialize, socket round-trip,
deserialize. A call is not a cheap function call. Batch, never per-element: ship work into
a single round-trip over data already resident in the graph (one all-pairs op, not a Python loop),
and keep tight per-element math in-process. The Rust Compute Guide
explains how this shapes every caller.