What is Jamii Sovereign OS?
Jamii Sovereign OS is a secure, decoupled, graph-relational platform built on top of SurrealDB 3.0.5. It provides high-assurance building blocks, zero-trust cryptographic vaults, and active Truth Graphs to orchestrate next-generation federated applications without central points of vulnerability.
The SurrealDB-Powered Spine
Rather than using a generic database as passive storage, Jamii is designed from the ground up to leverage the unique capabilities of SurrealDB v3.0.5 as a secure, graph-relational signaling and transactions engine.
By binding transactions directly to graph-relational topologies, SurrealDB allows us to express secure data relationships as physical paths. Under our strict 3.0.5 constraints, lower-level schemas govern all persistent data, ensuring complete isolation and consistency:
Schemaful Integrity
All tables in Jamii (such as truth_node, claim, and vault_claim) are strictly
configured as SCHEMAFULL. Every record field must match verified types, preventing structural leaks
and unauthorized table drifts at the physical storage layer.
RLS & Dynamic ABAC
Permissions are not managed by external API gateways. Instead, custom Row-Level Security (RLS) policies are compiled directly into the database engine. Access is validated on every SELECT, CREATE, UPDATE, and DELETE query by traversing graph paths in real-time.
DEFINE TABLE resource SCHEMAFULL;
DEFINE FIELD status ON resource TYPE string ASSERT $value INSIDE ["active", "suspended", "pending"];
DEFINE FIELD metadata ON resource TYPE object;
DEFINE FIELD metadata.traits ON resource TYPE array<string>;
Interface Contracts & OOP Governance
Active database invariants that redefine B2B tool execution.
In traditional enterprise software, APIs and governance models are passive documents or superficial middlewares. If an API gateway is bypassed, the database has no awareness of organizational rules. Jamii completely flips this model on its head by integrating Interface Contracts and OOP-Based Governance directly into the database transactions engine.
Active Database-Level Invariants
When Interface Contracts are combined with OOP-Based Governance, the system gains a powerful new ability: complete, zero-trust autonomous execution. External partners, AI agents, and local sub-systems (like the Akili engine) can dynamically discover and call tools with absolute assurance that they cannot violate organizational guidelines, perform invalid state transitions, or corrupt record states.
Active Verification
Instead of checking parameters in an application server, Interface Contracts evaluate parameters inside the database transaction. If an execution attempts to supply unverified data or trigger an illegal FSM transition, the transaction is rejected at the physical layer, ensuring database state sanity.
Secure AI tool-calling
AI agents (Akili engine) parse machine-readable manifests and the Canonical Naming System (cns://)
to discover tools dynamically. Because the Interface Contracts act as absolute boundary shields, AI can execute
real-world actions without risk of database injections or escalation.
OOP Portfolio Scopes
Governance is modeled using Object-Oriented Programming (OOP) paradigms. Personal, Community, and Organization entities are mapped to distinct, encapsulated Portfolio Scopes. Portfolios act as secure container classes that enforce strict boundaries, preventing portfolios-of-portfolios from creating circular references.
Capability Inheritance
By utilizing dynamic containment edges inside the spatial-semantic Truth Graph, resources automatically inherit capabilities from their parent containers. An enterprise can grant a capability to a department folder, and child vaults dynamically inherit policies instantly, avoiding tedious manual ACL backfills.
Tokens, Claims, and active Truth Graphs
The core spatial-semantic spine of Jamii is the Truth Graph, which represents all actors, resources, and cryptographically signed facts as a unified topological network of nodes and edges.
A Claim in Jamii is a verifiable, cryptographically sealed assertion representing a single fact (e.g., an age verification, an active device telemetry, or a signed medical report). These claims are mapped as nodes in the Truth Graph. The graph then resolves authorization queries by traversing edges in real-time.
How the Truth Graph Differs from Traditional Architectures
Jamii bridges the gap between high-speed relational queries and strict cryptographic consensus. Here is how our architecture contrasts with traditional graph databases and blockchain ledgers:
| Capability | Jamii Truth Graph | Traditional Graph (e.g. Neo4j) | Blockchain Ledgers |
|---|---|---|---|
| Cryptographic Assurances | |||
| Processing Latency | |||
| Dynamic Lease Scopes | |||
| High-Throughput Queries | |||
| Zero-Trust Vaults |
Layered Conceptual Architecture
To manage complexity, ensure backwards compatibility, and establish a strict chain of custody for all system mutations, Jamii is organized into versioned, dependent conceptual layers called Strata.
Lower strata act as secure foundations for messaging and persistent auditing, while higher strata build semanticNaming directories, dynamic governance boundaries, and high-level applications. Every layer OVERWRITES or inherits properties from the layer below:
Identity, Event Fabric & Naming Directories
Establishes core persistency schemas, audit sinks, NATS outbox queues, and the Canonical Naming System (CNS).
Defines the base fn::utc_now functions to enforce consistent temporal coordinates across all federated cells.
Mission Workflows & Shared Primitives
Implements decoupled Finite State Machine (FSM) bindings and data structures. Creates baseline zero-trust folders, attestation tokens, and cryptographic traits.
Governance Policy & Operations
Enforces Attribute-Based Access Control (ABAC), dynamic capability bindings, and portfolio scopes. Integrates containment triggers for dynamic permission propagation down graph relationships.
Ecosystem Applications & Verification
Houses B2B application logics: chat, emergency dispatch (MARS), medical systems (AfiyaLink), service discovery, and verifiable credential issuing engines.
Portfolio Vaults & Doc Libraries
Provides B2B vault architectures, entity references, file claim mechanics, and hierarchical folders.
Implements the fn::file_claim function to create folder paths and cryptographically seal vault files in a single step.
Decoupled FSM Workflows & Sovereign Blueprints
Standard process engines run inside ephemeral application memory, making long-running workflows vulnerable to server reboots or process crashes. Jamii isolates process state completely by using database-level FSM definitions.
Our Finite State Machine (FSM) subsystem is written directly in SurrealDB table definitions and events, connected to durable NATS Outbox signaling queues. This architecture achieves absolute resilience: FSM states are represented as persistent table records that can span years or decades. State transitions represent transactions triggered only when cryptographic claims are successfully verified against Interface Contracts.
To install and orchestrate these complex environments without manual scripting, we use Sovereign Blueprints.
Blueprints are declarative, versioned configurations that specify exact schemas, security layers, and FSM transition paths.
When a blueprint is deployed via the fn::blueprint::install system function, the database dynamically provisions
all required tables, indexes, and NATS event bindings with zero manual intervention.
"Bring Your Own Vault" (BYOV) B2B Federation
For legacy B2B enterprises, migrating multi-terabyte SQL databases to modern decentralized ledgers represents a highly risky, expensive engineering barrier. Jamii overcomes this with the Bring Your Own Vault (BYOV) model.
Enterprises do not migrate their databases. Instead, they spin up a local Jamii Cell next to their legacy infrastructure. The enterprise maps its relational schemas to a secure local Information Vault and publishes access to external actors by registering cryptographically signed Claims onto the global Truth Graph:
Enterprise DB
Legacy SQL / CRM / EHR data
Local Jamii Vault
BYOV Cryptographic Boundary
Ecosystem Truth Graph
Global spatial-semantic queries
Because all queries inside the Truth Graph are routed through secure Proximity Leases and verified via Interface Contracts, the enterprise retains absolute control over its physical data boundaries. They can revoke access at any time by invalidating the local lease, guaranteeing absolute data sovereignty.
What You Can Build with Jamii Sovereign OS
Explore how developers deploy federated services across industries. See how the CNS naming directory, governance rules, and zero-knowledge claims orchestrate cross-organization capabilities that were previously impossible.
Acme Manifest
cns://acme-incLocal Vault
S12.V Crypt BoundaryAcme Legacy DB
SQL/HR DatabaseInitializes zero-trust containment bounds on localized SurrealDB instances, safeguarding records behind cryptographic claim indexes (Stratum S12.V).
Go Deeper: The Zero-Trust State Machine
Learn exactly how Jamii Sovereign OS guarantees mathematical certainty across decentralized boundaries using our Proof of Correct Execution (PoCE) Hash Chain framework.
Read the ZTSM Architecture Deep Dive