Intelligent Operating System (IOS)

• IOS is a system software integrating adaptive, AI-driven, and context-aware capabilities to dynamically balance resource efficiency and security.
• It emphasizes modularity and trans-layer abstraction with micro-library orchestration, enabling robust, transactional digital-physical state management.
• IOS platforms are deployed in autonomous labs, edge computing, vehicular control, and kernel-level AI, ensuring reproducibility and real-time efficiency.

An Intelligent Operating System (IOS) is a class of system software that integrates adaptive, AI-driven, and context-aware capabilities directly into the operating system architecture. IOS platforms bridge symbolic and numerical decision-making, provide workload awareness and dynamic self-configuration, unify digital and physical process control, and support advanced provenance and reproducibility assurances. In contrast to classical monolithic OSes, IOS architectures emphasize modularity, trans-layer abstraction, and pervasive support for autonomous and intelligent applications across laboratory automation, edge computing, vehicular control, and kernel-level AI workloads.

1. Foundational Principles and Definitions

The core objective of an Intelligent Operating System is to dynamically adapt structure and behavior toward high-level goals such as optimal latency, resource efficiency, security, and safety under variable conditions. In TenonOS, intelligence is synonymous with self-generation from a library of micro-libraries, dynamic module composition, and orchestration based on semantic reasoning over goals and constraints (Zhao et al., 29 Nov 2025). In UniLabOS, AI nativity refers to bridging digital (AI agent) and embodied (robotic/experimental) execution planes through typed, transactional abstractions (Gao et al., 25 Dec 2025). The Digital Foundation Platform (DFP) for vehicles extends the IOS definition to include hardware-agnostic functional orchestration, multi-layer Service-Oriented Architecture (SOA), and dynamic service discovery (Yu et al., 2022). Composable kernel architectures further generalize IOS as AI-integrated substrate capable of kernel-resident inference, adaptive scheduling, and neurosymbolic reasoning (Singh et al., 1 Aug 2025).

2. Domain-specific IOS Architectures

UniLabOS for Autonomous Laboratories

UniLabOS implements an IOS for autonomous scientific laboratories via the Action/Resource/Action&Resource (A/R/A&R) model. Actions (A), passive Resources (R), and composite devices (A⊕R) are unified in the abstraction space $\mathcal{U}=A\cup R\cup(A\oplus R)$, with each element encoded as a ResourceDict tracking unique ID, logical containment, static configuration, runtime state, and provenance. Laboratory structure is represented as a dual-topology: a logical ownership tree $G_L=(V, E_L)$ for hierarchical access and a physical connectivity graph $G_P=(V, E_P)$ for feasible transfer paths. Protocol steps operate over this duality to route physical actions and ensure digital-physical state consistency (Gao et al., 25 Dec 2025).

TenonOS in Edge Computing

TenonOS embodies an IOS as a composable, demand-driven edge OS architecture. The core innovation is the LibOS-on-LibOS model: a pool $L=\{l_1,\ldots,l_n\}$ of granular libraries from which both hypervisor (Mortise) and operating system (Tenon) images are synthesized on demand. An orchestration engine, guided by LLMs and a Lib-Graph dependency DAG $G=(L,E)$, selects and configures a minimal, workload-tailored set $S\subseteq L$ satisfying hardware and objective constraints. Mortise provides low-overhead VM abstraction, dynamic resource allocation, and inter-VM communication ($< 1$μs). Tenon offers deterministic real-time scheduling, low memory footprint (361 KiB), and linear scalability to 50+ threads (Zhao et al., 29 Nov 2025).

DFP for Connected Vehicles

The DFP architecture for intelligent vehicles decomposes the stack into five layers:

1. Hardware + HAL for device and compute abstraction.
2. OS core (type-zero hypervisor, RTOS, multi-guest domains).
3. Middleware layer (DDS, SOME/IP for pub/sub and RPC).
4. Functional software (data/plan/control/pipeline frameworks).
5. Application layer (ACC, LKA, AVP, cockpit, OTA). Each layer exposes north-bound APIs, supporting strong isolation, minimal coupling (reuse factor $R\propto1/\kappa$), and dynamic service registration. Zero-copy channels ($\approx50$μs latency), virtualization ($\delta_{hv}\approx5$μs context overhead), and hardware-agnostic service reuse enable rapid prototyping and reconfiguration (Yu et al., 2022).

Composable Kernel Architectures

In "Composable OS Kernel Architectures for Autonomous Intelligence," an IOS kernel is realized by generalizing Loadable Kernel Modules (LKMs) as AI computation units. A camera LKM triggers data ingestion, feature extraction, in-kernel deep network inference, and neurosymbolic processing, all in kernel space. Built-in inference engines, floating-point acceleration, and a real-time adaptive SCHED_ML scheduling class facilitate high-throughput ML workloads. The core formalism is the RaBAB–NeuSym layer, uniting symbolic (category theory morphisms, homotopy type theory) and differentiable logic directly within the kernel, providing mathematical guarantees for resource transformations and adaptive scheduling (Singh et al., 1 Aug 2025).

3. Transactional and Adaptive Control Mechanisms

A distinguishing feature of IOS platforms is their transactional, state-consistent orchestration of digital and physical or virtual actions:

• UniLabOS generalizes CRUD operations to CRUTD = {Create, Read, Update, Transfer, Delete}. Every CRUTD primitive is executed as an atomic transaction with explicit pre-/post-conditions and a two-phase reconcile to ensure that digital state and physical device transitions remain consistent. For Transfer, resource validation, path finding (over $G_P$), resource locking, actuation, post-sensing, and error-rollback are all systematically enforced, yielding robust provenance and rollback semantics (Gao et al., 25 Dec 2025).
• TenonOS leverages its orchestration engine to optimize system images under constraints:

$\min\; F_\text{cpu}(S) + \lambda F_\text{mem}(S)$

subject to aggregate CPU/memory budgets. The dynamic policy engine parses objective prompts, scores library matches using LLM embeddings, prunes invalid compositions, and guarantees dependency closure (Zhao et al., 29 Nov 2025).

• IOS Kernels realize adaptive scheduling via a specialized class (SCHED_ML) with real-time constraints, leveraging hardware performance counters for dynamic priority $$P_i\to P_i+\alpha(1-\text{cpu\_cycles}_i/C_\text{target})$$. Kernel modules are coupled using linear logic resource contracts, while orchestration and adaptation are realized across sensory, inference, and symbolic modules (Singh et al., 1 Aug 2025).

4. Distributed, Modular, and Service-Oriented Topologies

IOS designs uniformly depart from monolithic stacks in favor of modularity and dynamic topology:

Architecture	Abstraction Key	Composition Principle
UniLabOS	A/R/A&R, GL/GP graphs	Typed, transactional, dual-topology
TenonOS	LibOS-on-LibOS, DAG	Micro-library orchestration, Modularity
DFP	Layered SOA, API stack	Service discovery, hardware-agnostic APIs
Comp. Kernel	LKM-as-AI, RaBAB-HoTT	Neurosymbolic reasoning in kernel modules

This modularity enables:

• Protocol mobility: UniLabOS supports live migration of protocols across labs with topological invariance, compiling workflows against the current GL/GP (Gao et al., 25 Dec 2025).
• Dynamic edge orchestration: TenonOS self-generates environments per workload; Mortise supports on-demand VM lifecycle (Zhao et al., 29 Nov 2025).
• Plug-and-play expansion and dynamic reconfiguration: DFP’s service registry and layered APIs allow new hardware or application modules to bind into active pipelines at runtime. Module reuse and decoupling ratios are significantly improved compared to monolithic automotive stacks (Yu et al., 2022).
• Composability and functional reusability: Composable kernels enable dynamic AI pipeline assembly with explicit safety and privilege boundaries (Singh et al., 1 Aug 2025).

5. Provenance, Reproducibility, and Governance

Provenance and reproducibility are intrinsic to IOSs designed for mission-critical or science-driven domains:

• UniLabOS maintains high-fidelity provenance graphs at the granularity of each CRUTD transaction, spanning both digital decisions and material flows; human-in-the-loop approval gates and auditable overrides are enforced through explicit governance mechanisms (Gao et al., 25 Dec 2025).
• DFP enhances automotive software integrity, with SDKs and framework APIs tracking execution, module interaction, and dynamic updates; OTA features further augment reproducibility (Yu et al., 2022).
• TenonOS leverages modular micro-library composition, reducing the trusted computing base (TCB) and supporting hot-swap, minimal-side-effect updates (Zhao et al., 29 Nov 2025).

6. Performance Benchmarks and Comparative Analyses

Empirical results indicate substantive improvements over traditional stack architectures:

• UniLabOS achieves sub-100 ms actuation latencies, 10 Hz telemetry, and $<1$\% volume-tracking error over $10^4$ atomic transfers. Workflow orchestration is demonstrated in single-host, modular, and distributed closed-loop settings, with chain-of-custody maintained across isolated experimental domains (Gao et al., 25 Dec 2025).
• TenonOS reports real-time scheduling latency reduced by 40.28% vs. Zephyr, boot times as low as 0.035 s (solo configuration), and linear scalability to 50+ threads. The memory footprint remains under 400 KiB, outpacing traditional Xen+Linux dual-stacks in efficiency and dynamic adaptability (Zhao et al., 29 Nov 2025).
• DFP achieves intra-node message latencies of $\approx50$μs (for 1 kB–1 MB payloads), with hypervisor context switch costs of $\approx5$μs and tripling module reuse factor over legacy systems (Yu et al., 2022).
• Composable Kernels attain in-kernel inference and symbolic reasoning cycles tightly bounded by FP context management and scheduling quantum, with functional correctness maintained by the RaBAB–NeuSym formal layer (Singh et al., 1 Aug 2025).

7. Implications and Future Directions

The IOS paradigm drives a decisive shift from static resource orchestration to platforms with self-adaptive, semantically aware, and cross-domain autonomy. Key developments include:

• Fine-grained modularity and dependency-closure for minimum TCB and maximal adaptability (Zhao et al., 29 Nov 2025).
• Trans-layer provenance tracking and two-phase digital-twin reconciliation to enforce physical-digital consistency (Gao et al., 25 Dec 2025).
• Layered SOA facilitating heterogeneity, safety, and time-to-market for domain-specific intelligent vehicles (Yu et al., 2022).
• Mathematically grounded neurosymbolic kernels enabling kernel-space AI and provable safety/compositionality (Singh et al., 1 Aug 2025).

This axis of innovation underlies scalable, agent-ready environments for autonomous science, cyber-physical control, and intelligent edge/cloud infrastructure, positioning IOS designs as foundational for future agentic and learning-aware computational substrates.