Overview
The Spatial AI Operating System
Nexma is a Spatial AI Operating System. One foundation holds the world model, one agent operates it through a fixed set of generic primitives, and every view and capability is that same operating system surfaced a different way.
Core concepts
Most spatial software is a stack of point products bolted together: a database here, a tile server there, a desktop GIS, a routing service, a dashboard, and a pile of export jobs keeping them roughly in sync. Nexma collapses that into a single operating system with one source of truth.
- One foundation. The Nexma DataStore is a versioned, branchable spatial filesystem. It holds the entire world model — entities, relationships, geometry, constraints, feeds, runs, and history — and is the single source of truth.
- One agent. Jax runs on the Nexma AgentEngine and reads and writes the DataStore through eight generic primitives. It has no domain-specific tools. A water valve and a fiber splitter are both files.
- One world model, typed. The active Ontology types every object in the store. Load a different ontology and the application reconfigures — entities, layers, validators, and Jax's behavior all change with no code rewrite.
- Every view renders from the foundation. The map, tables, the graph, side panels, the mobile app, and Jax all read and write the same files. There is no separate AI workspace that drifts out of sync with the real one.
The thesis is simple: every capability — engineering, investigation, detection, operations — is the same operating system surfaced differently. Nothing is hardcoded to a single domain.
How it works
The stack is layered. Data flows up from sources into the world model; the agent reasons over it and writes back down; every surface renders reactively from the same files.
1┌──────────────────────────────────────────────────────────┐
2│ SURFACES │
3│ Map · Tables · Graph · Panels · Mobile · API · MCP │
4│ Every view renders reactively from the DataStore │
5├──────────────────────────────────────────────────────────┤
6│ JAX (runs on Nexma AgentEngine) │
7│ Reads, reasons, writes via 8 generic primitives: │
8│ Read · Write · Edit · Delete · Glob · Grep · Run · Solve │
9│ Engines: MathEngine · GeoEngine · InsightEngine · │
10│ SatelliteEngine │
11├──────────────────────────────────────────────────────────┤
12│ WORLD MODEL │
13│ Ontology (typed schema) · Skills (domain packages) │
14│ Constraints enforced on every write │
15├──────────────────────────────────────────────────────────┤
16│ NEXMA DATASTORE — the single source of truth │
17│ Versioned, branchable spatial filesystem │
18│ One write, every surface reacts │
19├──────────────────────────────────────────────────────────┤
20│ DATA │
21│ SyncEngine · Event Broker · DataBase │
22│ Telemetry · Enterprise systems · Public & geospatial │
23└──────────────────────────────────────────────────────────┘Read it bottom to top. Sources feed the DataStore through the data engines; the world model types and constrains what lands there; Jax operates on the typed store; and every surface is just a renderer over the same files.
The single source of truth
The defining property is that there is exactly one place where state lives. When Jax routes a network, reassigns a logistics route, or resizes a forestry zone, it writes once to the DataStore — and the map re-renders, the relevant table updates, the graph redraws, and the mobile app sees the change. No exports, no sync jobs, no reconciliation between systems.
Because the store is the truth and every view is a renderer, there is no drift. A human edit and an agent edit are the same kind of change — a versioned write to a file — so both are reviewable, mergeable, and reversible.
Domain-agnostic by construction
Nexma was first proven on fiber-to-the-home, but the platform is horizontal. The domain never lives in the code. It lives in the Ontology (what exists and how it connects) and in Skills (what Jax can do with it). Swap those and a fiber planner becomes a water-grid planner, an electric-grid tool, a drone-corridor designer, or a logistics planner — with zero code changes.
This is why the agent operates only on generic primitives. Capability comes from the tools; meaning comes from the ontology; when the schema changes, the agent does not.
Where to go next
- Understand the foundation: DataStore-first architecture.
- Learn the agent's tool surface: The eight primitives.
- See the runtime Jax executes on: The Agent Computer.
- Connect existing systems: Interoperability.
- Choose a deployment: Supported platforms.
- Review the controls: Security and governance.