UniLabOS: Autonomous Lab Operating System

• UniLabOS is an AI-native operating system that integrates digital twin state management with agent-driven experimentation for autonomous laboratories.
• It employs a CRUTD transactional protocol and dual graphs to ensure atomic, reproducible operations across heterogeneous lab devices.
• The platform's distributed architecture and extensible drivers enable scalable, safe, and provenance-rich orchestration of experimental workflows.

UniLabOS is an AI-native operating system engineered to unify and orchestrate autonomous laboratories by bridging digital, agent-driven decision-making with embodied experimentation. By introducing a transactional execution kernel, strict type systems, and dual representations of laboratory state, UniLabOS ensures scalable, reproducible, and provenance-rich control across heterogeneous laboratory topologies and devices. The platform formalizes laboratory elements into a composable, stateful abstraction, thus creating a robust substrate for self-driving scientific discovery and agent-driven closed-loop experimentation (Gao et al., 25 Dec 2025).

1. Fundamental Abstractions: The A/R/A&R Model

UniLabOS defines a typed ontology for all laboratory entities, assigning every physical or logical item into one of three disjoint classes via the type function $\tau: E \to \{\mathrm{R}, \mathrm{A}, \mathrm{A%%%%0%%%%R}\}$, where $E$ is the set of all entities:

• Resource (R): Passive containers that hold materials (e.g., vials, plate wells).
• Action (A): Pure, stateless actuators acting on resources (e.g., pumps, valves).
• Action & Resource (A&R): Composite devices that both hold and manipulate material (e.g., heater–stirrers).

Each entity $e \in E$ is specified with a UUID ($e.\mathrm{id}$), a parent pointer ($e.\mathrm{parent\_id}$), and a structured schema $$\mathrm{ResourceDict}(e) = \{\mathrm{config}, \mathrm{data}, \mathrm{extra}\}$$, delineating static constraints (capacity, permitted materials), real-time state (occupancy, temperature), and provenance metadata. Driver methods are strictly typed, and UniLabOS utilizes Python AST-based inspection at registration to enforce type correctness and method contract adherence—blocking invalid method-resource pairings and ensuring concurrency safety via resource locking.

2. Laboratory State Representation: Dual-Topology Model

To disentangle logical possession from material transferability, UniLabOS maintains two coupled graphs:

• Logical Resource Tree ($T = (E, E_\mathrm{parent})$): Encodes hierarchical containment relationships (e.g., Room→Bench→Device→Container→Sample).
• Physical Connectivity Graph ($G = (E, E_\mathrm{phys})$): Encodes possible pathways for material or data exchange via undirected edges (e.g., fluidics, robotic reachability).

Any material transfer requires the existence of a valid path $P = \{e_0, ..., e_k\} \subseteq G$ satisfying $P[0] = \mathrm{src}_\mathrm{parent}$, $P[k] = \mathrm{dst}_\mathrm{parent}$. UniLabOS automatically resolves routing and control sequences along $P$ based on real-time graph state.

3. Transactional Integrity: The CRUTD Protocol

Extending the conventional CRUD operations, UniLabOS introduces CRUTD (Create, Read, Update, Transfer, Delete), elevating Transfer to a first-class, atomic protocol element:

• Create: Inserts a new entity into the logical tree, with constraints enforced on uniqueness and containment.
• Read: Retrieves $\mathrm{ResourceDict}(e)$ without side effects.
• Update: Atomically modifies state or metadata fields.
• Transfer: Atomically moves an entity between containers following a validated path in $G$; preconditions include lock acquisition and simulation in the digital twin, followed by physical actuation, post-checks (sensor/vision), commit or rollback, and detailed provenance logging.
• Delete: Decommissions an entity into a non-schedulable Trash branch, retaining its history for auditability.

Each CRUTD event is timestamped and causally linked in a provenance graph $K = (V_\mathrm{CRUTD}, E_\mathrm{causal})$, supporting full experimental replay and traceability.

CRUTD Operation Table

Operation	Preconditions	Postconditions
Create	$e.\mathrm{id}$ non-existent	$e \in E$, correct contingency
Read	$e \in E$	$\mathrm{ResourceDict}(e)$ returned
Update	$e \in E$	State fields updated
Transfer	Path $P$ in $G$ exists, locks available	$e.\mathrm{parent} \leftarrow$ dest, provenance updated
Delete	$e \in E$	Moved to Trash, data preserved

4. Distributed System Architecture and Workflow

UniLabOS is architected as a distributed edge–cloud operating kernel. The intranet (LAN) employs a host node bridging to edge device nodes via ROS 2 over DDS, using the following communication primitives:

1. Services for discovery and hot-swappable registration (AST-inspected drivers)
2. Services for material (CRUTD) synchronization
3. Actions for long-running actuation tasks with goal-feedback-result and rollback on error
4. Topics for telemetry (pose, sensor streams)

Device nodes broadcast DDS beacons; newly registered devices are injected live into $T$ and $G$, supporting dynamic laboratory configuration. The extranet (WAN) handles asynchronous scheduling, aggregation, and cross-site orchestration via a global scheduler, enabling queued execution and protocol mobility: abstract CRUTD sequences can be mapped to any compatible topology by re-solving routing in $G$, decoupling protocol logic from specific hardware arrangements.

5. Governance, Extensibility, and Safety

UniLabOS supports layered autonomy and human-in-the-loop controls. Operators can define workflows, policies, and mandatory approval checkpoints through a cloud interface. Critical CRUTD events (e.g., hazardous reagent handling) can be paused for manual review, and all governance decisions are logged in the extra metadata of $\mathrm{ResourceDict}$. Extension is accomplished via:

• Instrument Drivers: Python classes with strictly typed methods. The AST inspector validates signatures for system integration and enables hot-loading.
• Decision Agents: Agents interact via the Model Context Protocol (MCP), submitting high-level CRUTD intents and receiving state via ROS 2. Safety is enforced via type checking, pre-dispatch simulation, and lock-based isolation, abstracting agent reliability from laboratory safety guarantees.

6. Empirical Validation Across Laboratory Contexts

UniLabOS has been demonstrated in the following real-world applications:

• Liquid-Handling Workstation: Single host, single device scenario. Utilized a topology-aware abstraction and an LLM-based agent to achieve sub-millimeter pipetting accuracy with full volume/tip wash traceability.
• Modular Organic Synthesis Platform: Single host, multi-device system. Executed a two-step Grignard + esterification protocol using an XDL-style recipe, automating pathfinding and valve coordination in $G$, delivering 5.3g of propargyl ester with NMR-verified purity. Protocol portability across valve configurations was demonstrated.
• Distributed Electrolyte Foundry: Multi-host, LAN/WAN connected. Global scheduler coordinated formulation, assembly, and testing with chain-of-custody preserved via nested provenance. WAN fault tolerance allowed for queued local execution during network dropouts, with state synchronization upon reestablishment.
• Decentralized Closed-Loop Control: Computation-intensive peer-to-peer (P2P) system for water electrolysis. Real-time sensor feedback was streamed to an HPC cluster, which issued updates directly to edge controllers, maintaining sub-second response and system stability even under WAN outage.

7. Scalability, Reproducibility, and Future Outlook

UniLabOS achieves reproducibility and provenance by logging every CRUTD event, synchronizing digital twin state with laboratory action, and encoding causality in a replayable provenance graph. DDS-based peer-to-peer communication scales to tens of devices and multi-site deployments without central broker bottlenecks. Protocol mobility, enabled by topological invariance, allows migration of experiment logic across hardware configurations.

Identified challenges include the hardware reality gap (calibration discrepancies across labs), the need for advanced, policy-driven scheduling and arbitration under multi-agent operation, enrichment of sensory integration (vision, spectroscopy), and automated recovery from anomalies. Expansion toward global Laboratory-as-a-Service (LaaS), supporting cross-institutional identity, multi-tenancy, and geopolitically distributed orchestration, is considered an important future direction. These advancements position UniLabOS as a deterministic, programmable layer for the next generation of scalable, agent-driven, and reproducible experimental science (Gao et al., 25 Dec 2025).