Every System Omni-Compass Governs
1,107 governed system archetypes across Compute & Silicon, Orchestration & Observability, Data & Storage, and Domains & AI. One governing law. Every layer. Every scale.
197 Archetype Classes. 1,107 Governing Nodes.
These are not the same number. They measure different things. Understanding the difference is the foundation of understanding what Omni-Compass actually does.
197 — Archetype Classes
An archetype class is a named category of system — Kubernetes, PostgreSQL, NVIDIA GPU, ROS 2, Nuclear Reactor. There are 197 of them across 4 realms. This is the taxonomy. The menu. The complete list of every type of system the engine is architecturally designed to govern.
1,107 — Governing Nodes
A governing node is an individual, parameterized instance of a governed system — with its own admissibility constraints, convergence parameters, and state-space definition. One archetype class contains many governing nodes. Kubernetes alone has nodes for the scheduler, kubelet, etcd, API server, controller manager, kube-proxy, CNI layer, admission controller, resource quota controller, and HPA controller. All 1,107 nodes are loaded from catalog_v5.csv at engine startup.
The analogy: The analogy: 197 is the blueprint for every room in the building. 1,107 is every individual circuit, valve, and sensor that has been wired, plumbed, and calibrated inside those rooms.
Realm 0 — Compute & Silicon
Every Compute Substrate. Every Silicon Architecture.
Compute & Silicon is the foundation layer — the physical hardware that everything else runs on. Cloud hyperscalers (Azure, Google Cloud, Amazon), GPU silicon (NVIDIA H100, AMD, Intel), distributed compute engines (Spark, Flink, Hadoop YARN), and every processor architecture from x86 to ARM to FPGA. The Omni-Compass engine governs above this layer — it does not replace the hardware, it governs the workloads that run on it. The +5.3% GPU gain is the direct measurement of this relationship on NVIDIA H100 silicon.
Sample modules in this realm
Realm 1 — Orchestration & Observability
Every Scheduler. Every Mesh. Every Pipeline.
Orchestration & Observability is the layer that decides where work runs, how it flows, and whether it is healthy. Kubernetes (the dominant compute orchestrator), Kafka (the dominant event stream), every service mesh (Istio, Linkerd, Envoy), every CI/CD system (GitHub Actions, Jenkins, Argo CD), every observability platform (Prometheus, Grafana, Datadog, Splunk), and every security policy engine (OPA/Gatekeeper, Vault, Falco). The Omni-Compass engine governs above the Kubernetes scheduler — governing the governor. The +22.2% Kubernetes gain is the direct measurement of this relationship.
Sample modules in this realm
Realm 2 — Data & Storage
Every Database. Every Cache. Every Storage System.
Data & Storage is the layer that holds state. Every major relational database (PostgreSQL, MySQL, Oracle, SQL Server, MariaDB, CockroachDB), every NoSQL store (MongoDB, Cassandra, DynamoDB, Redis), every search engine (Elasticsearch, OpenSearch, Solr), every distributed storage system (Ceph, MinIO, HDFS), and every infrastructure-as-code tool (Terraform, Ansible, Pulumi). The engine governs query admission, connection pooling, I/O scheduling, and storage throughput above every data layer. PostgreSQL (+4.2%), MySQL (+2.2%), and Redis (+0.1%) are the sealed measurements.
Sample modules in this realm
Realm 3 — Domains & AI
AI. Robotics. Energy. Aerospace. Defense.
Domains & AI is the application layer — every vertical domain where compute infrastructure is mission-critical. ML serving platforms (Kubeflow, MLflow, Triton, TF Serving), robotics systems (ROS 2, MoveIt, Isaac Sim, every motion axis type), energy systems (SCADA, nuclear reactors, wind turbines, solar arrays, HVDC links), aerospace systems (flight computers, ADCS, IMU, GPS/GNSS, reaction wheels, thruster arrays), and defense systems (C2, radar, EW, targeting computers, autonomous UAV/UGV/USV). The governing law is domain-agnostic by construction — it operates on the state-transition topology of any governed system, regardless of the physical substrate.
Sample modules in this realm
What Every Term Means
Every word on this page has a precise definition. This is not marketing language. These are engineering terms with exact meanings.
Muscle / Node
The fundamental unit of governance. A muscle is a single, individually parameterized governed system instance — one Kubernetes scheduler, one PostgreSQL connection pool, one NVIDIA H100 GPU, one wind turbine controller. The engine governs muscles. 1,107 muscles are loaded from catalog_v5.csv at startup. The term 'muscle' reflects the biological analogy: just as a biological organism governs its muscles through a central nervous system, Omni-Compass governs its muscles through a single closed-circle control plane.
Archetype Class
A named category of governed system. Kubernetes is an archetype class. PostgreSQL is an archetype class. NVIDIA GPU is an archetype class. There are 197 archetype classes across 4 realms. An archetype class defines the governing relationship — the parameters, the admissibility constraints, the convergence proof — that applies to every individual muscle of that type. One archetype class, many muscles.
Realm
A top-level domain grouping of archetype classes. There are 4 realms: Compute & Silicon (hardware and distributed compute), Orchestration & Observability (schedulers, meshes, CI/CD, monitoring), Data & Storage (databases, caches, search, storage), and Domains & AI (ML platforms, robotics, energy, aerospace, defense). Every archetype class belongs to exactly one realm. Every realm is governed by the same engine under the same law.
Governing Node
The engine-side representation of a governed muscle. A governing node contains the admissibility constraints, the convergence parameters, the state-space definition, and the control law instantiation for one specific muscle. When the engine starts, it loads 1,107 governing nodes from catalog_v5.csv. Each node is the engine's formal model of one governed system instance.
Benchmarked (V25 Sealed)
A module is benchmarked when a sealed V26 twin-pair benchmark run exists for it — a SHA-256 fingerprinted receipt produced against real infrastructure, with a real baseline arm and a real governed arm running identical workloads simultaneously. Six modules carry this designation: Kubernetes (+22.2%), PostgreSQL (+4.2%), MySQL (+2.2%), Redis (+0.1%), NVIDIA GPU (−1.3% energy per request, GAIN), and the whole-system composite (+20.0%). These are the only numbers the site claims as measured gains.
Architectural Coverage
A module has architectural coverage when the engine is formally designed to govern it — the governing node definition exists in catalog_v5.csv, the admissibility constraints are specified, the convergence proof applies — but no individual sealed benchmark run has been produced for it yet. 191 of the 197 archetype classes are in this category. Architectural coverage is not a weaker claim. It is a different claim: the engine is built to govern these systems. The benchmark is the proof that the engine works. The catalogue is the declaration of everything it governs.
Closed-Circle Convergence
The governing law. For any admissible system state in any governed domain, the engine will converge the system to its target operating point in finite time. The convergence is guaranteed by the Lyapunov stability proof. The closed-circle constraint is a Lyapunov function whose derivative is strictly negative definite across the governed state space. No state escapes the governing boundary. No system drifts. No runaway condition is possible within the governed envelope.
Admissibility Constraint
The set of conditions a system state must satisfy to be accepted by the governing engine. Every governing node has its own admissibility constraints — the boundaries within which the closed-circle convergence proof holds. A state that violates admissibility is rejected before it is applied. This is the mechanism that prevents runaway conditions: the engine does not attempt to govern states it cannot guarantee convergence for.
Sealed Receipt
A SHA-256 fingerprinted benchmark run record. Every V25 benchmark run produces a sealed receipt: the run ID, the fingerprint, the twin-pair configuration, the workload specification, the baseline result, the governed result, and the computed gain. The fingerprint is on GitHub. The methodology is published. The receipt is verifiable in-browser. The sealed receipt is the difference between a claim and a fact.
All 176 modules
Compute & Silicon
18 modulesAzure Cloud
Microsoft hyperscale cloud
Google Cloud
Google hyperscale cloud
Amazon Cloud
AWS hyperscale cloud
NVIDIA GPU
Parallel GPU compute
Intel CPU
x86 general-purpose CPU
AMD CPU / GPU
x86 + RDNA compute silicon
ARM CPU
Low-power RISC processor
Apple M-Series
Unified memory SoC
Qualcomm SoC
Mobile & edge SoC
FPGA Array
Reconfigurable logic fabric
ASIC Engine
Fixed-function silicon
TPU Cluster
Tensor processing unit
Spark
Large-scale batch compute
Flink
Stateful stream processing
Storm
Real-time stream compute
Hadoop YARN
Cluster resource mgr
Ray
Distributed ML compute
Dask
Parallel Python compute
Orchestration & Observability
57 modulesKubernetes
Container scheduling & ops
Docker Swarm
Native Docker clustering
Nomad
Multi-workload scheduler
Mesos
Distributed resource pool
OpenShift
Enterprise Kubernetes platform
Rancher
Multi-cluster K8s management
Kafka
High-throughput event stream
RabbitMQ
AMQP message broker
NATS
Lightweight pub/sub bus
Pulsar
Multi-tenant message stream
ActiveMQ
JMS enterprise broker
ZeroMQ
Brokerless socket messaging
Prometheus
Time-series metrics scraper
Grafana
Metrics dashboards & alerts
OpenTelemetry
Unified telemetry pipeline
Jaeger
Distributed request tracing
Zipkin
Latency trace collector
Datadog
SaaS observability platform
Dynatrace
AI-powered full-stack APM
Turbonomic
AI resource management
New Relic
Cloud observability & APM
Elastic APM
App performance monitoring
Splunk
Log analytics & SIEM
Argo CD
GitOps continuous delivery
Flux CD
Git-driven K8s sync
Jenkins
Extensible CI/CD automation
GitHub Actions
Cloud-native CI/CD pipelines
GitLab CI
Integrated DevOps pipelines
CircleCI
Fast cloud CI/CD
Tekton
K8s-native pipeline engine
Spinnaker
Multi-cloud CD platform
Istio
mTLS service mesh control
Linkerd
Lightweight service mesh
Consul
Service discovery & mesh
Envoy
High-perf L7 proxy
NGINX
Web server & reverse proxy
HAProxy
TCP/HTTP load balancer
Traefik
Cloud-native edge router
Cilium
eBPF kernel networking
Calico
Network policy & security
Flannel
Simple K8s overlay network
Vault
Secrets & encryption mgmt
Cert-Manager
TLS certificate automation
Falco
Runtime threat detection
OPA/Gatekeeper
Policy-as-code enforcement
Kyverno
K8s-native policy engine
Trivy
Container vulnerability scan
Snyk
Dev-first security scanning
Aqua Security
Full-lifecycle container sec.
Terraform
Cloud infra provisioning
Pulumi
Code-first IaC engine
Ansible
Agentless config automation
Chef
Ruby-based config mgmt
Puppet
Declarative config mgmt
SaltStack
Event-driven automation
CloudFormation
AWS native IaC templates
CDK
Code-defined AWS stacks
Data & Storage
36 modulesPostgreSQL
Advanced open-source RDBMS
MySQL
Widely deployed RDBMS
MariaDB
MySQL-compatible fork
Oracle DB
Enterprise relational DB
SQL Server
Microsoft enterprise RDBMS
CockroachDB
Geo-distributed SQL
YugabyteDB
Cloud-native distributed SQL
TiDB
HTAP distributed SQL
MongoDB
JSON document database
Couchbase
Mobile-ready document DB
DynamoDB
AWS serverless key-value
Firestore
Google real-time document DB
Cassandra
Wide-column distributed DB
ScyllaDB
Low-latency wide-column DB
HBase
Hadoop-native column store
Neo4j
Native graph database
ArangoDB
Multi-model graph & doc DB
TigerGraph
Massively parallel graph DB
Redis
In-memory data structure store
Memcached
Distributed memory cache
Hazelcast
In-memory data grid
Varnish
HTTP reverse proxy cache
Ehcache
Java application cache
Elasticsearch
Full-text search & analytics
OpenSearch
Open-source search engine
Solr
Enterprise search platform
Typesense
Fast typo-tolerant search
Meilisearch
Instant search engine
Ceph
Unified distributed storage
MinIO
S3-compatible object store
Rook
K8s storage operator
Longhorn
Cloud-native block storage
OpenEBS
Container-attached storage
GlusterFS
Scale-out network filesystem
HDFS
Hadoop distributed filesystem
NFS
Network file share protocol
Domains & AI
65 modulesEnterprise
IT ops & business systems
Defense
Military command & control
Aerospace
Flight & spacecraft systems
Energy
Grid, power & generation
Manufacturing
Factory floor & process ctrl
Robotics
Motion axes & robot control
AI / ML
AI inference & model ops
Kubeflow
ML pipelines on Kubernetes
MLflow
ML experiment tracking
Seldon Core
K8s model serving platform
BentoML
Model packaging & serving
Triton Inference
NVIDIA GPU model server
TF Serving
TF production model server
TorchServe
PyTorch model serving
W&B
ML experiment & run tracking
DVC
Data & model versioning
Feast
Feature store for ML
Tecton
Enterprise feature platform
ROS 2
Robot operating system
MoveIt
Robot arm motion planning
Nav2
Autonomous robot navigation
Gazebo
Physics-based robot sim
Isaac Sim
NVIDIA robot simulation
Webots
Open-source robot simulator
CoppeliaSim
Versatile robot sim platform
Servo Axis
Precision rotary motion axis
Linear Actuator
Linear motion drive
Stepper Motor
Discrete step position ctrl
BLDC Motor
Brushless DC torque drive
Hydraulic Act.
High-force fluid power axis
Pneumatic Act.
Compressed-air motion axis
Battery Pack
Electrochemical energy store
Supercapacitor
Ultra-fast charge buffer
Flywheel
Kinetic energy storage
Solar Array
Photovoltaic power generation
Wind Turbine
Aerodynamic power generation
Gas Turbine
Combustion power generation
Nuclear Reactor
Fission baseload generation
Fuel Cell
Electrochemical power gen.
HVDC Link
High-voltage DC transmission
SCADA
Grid supervisory control
EMS
Energy management system
DMS
Distribution management sys.
Flight Computer
Onboard avionics processor
ADCS
Attitude determination & ctrl
IMU
Inertial measurement unit
GPS / GNSS
Satellite position & timing
Star Tracker
Stellar attitude reference
Reaction Wheel
Momentum-based attitude ctrl
Thruster Array
Propulsive attitude control
Propulsion Ctrl
Engine throttle & sequencing
Thermal Controller
Spacecraft thermal regulation
Power Conditioning
Bus voltage regulation
Telemetry Downlink
Data transmission to ground
Command Uplink
Ground command reception
C2 System
Command & control network
Radar Controller
RF target detection & track
Sonar Array
Underwater acoustic sensing
EW System
Electronic warfare & jamming
Targeting Computer
Fire control & aim solution
Auto. UAV
Unmanned aerial vehicle
Auto. UGV
Unmanned ground vehicle
Auto. USV
Unmanned surface vessel
Logistics AI
Supply chain optimization
Cyber Defense
Network threat response
V25 Sealed BenchmarkModules marked with a checkmark carry a sealed V25 run identifier — a SHA-256 fingerprinted benchmark receipt produced against real infrastructure. All other modules are governed by architectural coverage: the engine is formally designed to govern them; individual sealed runs are in progress.