TL;DR for operators
An AI agent can write an executable experimental procedure without knowing whether the laboratory can perform it. Equipment capabilities, sample availability, container compatibility, and the consequences of earlier operations all matter.
Li and colleagues propose representing these constraints computationally, then checking generated workflows before hardware dispatch. Their implementation translates 49 workstation specifications into 63 executable Function Skills. Four constructed workflows passed structural analysis and stateful simulation with zero mandatory errors and zero advisory warnings.
For robotic laboratory operators, the practical contribution is a pre-dispatch verification layer. It can identify violations of explicitly modeled constraints before commands reach equipment. It cannot establish that those constraints are complete, that instruments will behave as simulated, or that an experiment will produce scientifically valid results.
A procedure can be executable code and still be impossible to perform
Consider an AI agent preparing a robotic chemistry experiment. Its program calls legitimate instrument functions, but attempts to transfer a sample after an earlier operation has consumed it. Every function may exist, and the Python code may be syntactically correct. The proposed sequence nevertheless conflicts with the laboratory’s evolving physical state.
Checking the program’s syntax does not resolve that conflict. The laboratory controller needs to know which samples exist, where they are located, what operations have already changed them, and which actions remain permissible.
In A computable representation of the physical laboratory enables verifiable workflows, Xiaobo Li and colleagues1 address this representational problem. Their contribution is not another method for generating experimental instructions. It is a computational description of the laboratory against which generated instructions can be evaluated.
The distinction matters because an agent’s ability to produce an apparently complete procedure says little about whether that procedure is operationally admissible.
The laboratory becomes a system of identifiable objects and constrained changes
The framework represents samples, containers, locations, measurements, and provenance through typed research objects. These objects retain their identities as operations modify their states or append observations.
An instrument operation is represented by more than a callable function. Its contract specifies the required inputs, parameters, preconditions, constraints, expected state changes, and returned information.
The paper expresses operation admissibility through a predicate:
Here, $S_t$ is the relevant laboratory state, $\theta_i$ contains the operation’s parameters, and $P_i$ checks whether operation $i$ is permitted under its registered contract.
A transfer operation, for example, can be checked against modeled requirements concerning its source, destination, and available contents. The validity of the next operation depends on the state produced by the preceding one.
This formalism changes what the system can check. Instead of evaluating isolated equipment commands, it can evaluate state-dependent operations over persistent laboratory objects.
The conceptual representation is richer than the operational simulator’s implemented state, however. A property absent from the executable model cannot be reliably checked merely because the framework can represent it in principle.
Source: A computable laboratory state–action space; Methods—Research-object and operation representation; Supplementary Notes 1–2.
Five operators make experimental control flow checkable
Real experimental procedures require more than sequential commands. Some measurements determine subsequent actions; optimization requires repeated operations; independent characterization may proceed concurrently; and certain preparation stages must not be interrupted.
The authors introduce five recursively composable workflow operators:
- Sequence: Enforces dependencies between operations.
- Bounded loop: Permits repeated execution while requiring finite iteration bounds.
- Conditional branch: Selects an execution path from explicit conditions, with mutually exclusive and exhaustive alternatives.
- Parallel fork–join: Supports concurrent branches subject to non-conflicting state changes.
- Protected interval: Prevents prohibited interleaving during operations that require uninterrupted execution.
These operators supply a common structure for workflow composition. They make it possible to inspect whether a proposed experiment respects ordering, termination, branching, concurrency, and scheduling constraints.
The work is especially relevant when experimental decisions depend on intermediate measurements. Such workflows cannot always be represented faithfully as a fixed list of instrument calls.
Source: Workflows as compositional programs; Supplementary Notes 3–4.
Static analysis checks the recipe; simulation checks its changing state
The implementation connects this representation to executable laboratory interfaces.
A registered inventory of 49 workstation specifications—45 physical workstations and four virtual control-flow modules—is compiled into 63 Function Skills. Each skill exposes a constrained operation that an agent can use when constructing a Python workflow.
Validation then proceeds through two complementary mechanisms.
Static analysis examines the generated program’s abstract syntax tree. It restricts imports, callable functions, supported syntax, and entry points, and checks that the recipe fits the permitted workflow representation. The reported evaluation uses analysis through optimization level O2, without enabling the more aggressive O3–O4 transformations.
Stateful simulation executes the accepted workflow against a shared modeled laboratory state. Unlike a check of isolated commands, it propagates the consequences of earlier operations into later admissibility decisions.
The simulator distinguishes mandatory MUST constraints from advisory SHOULD constraints. It applies a validate-then-commit policy: when a mandatory condition fails, the system returns structured diagnostics without committing the affected state transition.
This is a meaningful engineering control. The agent can receive specific information about a modeled violation rather than discovering it through an attempted physical operation.
It does not establish the success rate of automatic repair. Although the architecture supports diagnostic-guided regeneration, the reported evaluation does not measure regeneration reliability across repeated failures.
Source: Engineering executable semantics; Methods—Static analysis and stateful simulation; Supplementary Notes 6–7.
Four workflows passed the modeled checks
The main evaluation uses four constructed scientific-intent cases. The agent receives scientific objectives and high-level control requirements rather than a complete prescribed sequence of workstation operations.
| Laboratory scenario | Workflow structure | Demonstrated control logic |
|---|---|---|
| Fe coordination and oxygen-evolution planning | 27 nodes, 27 simulated steps, 11 workstations | Linear experimental procedure |
| Layered double hydroxide synthesis and HMF oxidation | 22 nodes, 31 simulated steps, 11 workstations | Protected preparation and parallel analytical branches |
| Furfural hydrogenation and chromatography optimization | 20 nodes, 23 simulated steps | Bounded iterative optimization |
| ZnO synthesis and spectroscopy | 27 nodes, 30 simulated steps, 15 workstations | Parallel characterization and adaptive dilution |
All four accepted workflows used registered capabilities and passed structural and stateful-simulation checks with zero MUST errors and zero SHOULD warnings.
The difference between structural nodes and simulated execution steps is relevant: workflow control structures can cause execution counts to differ from the number of nodes in the program.
These results are the paper’s main implementation evidence. They demonstrate that the representation and validation pipeline can accommodate several laboratory scenarios and control-flow patterns within the registered model.
They are not estimates of general workflow-generation reliability. Four constructed cases, without repeated stochastic trials or a controlled comparison, cannot establish an expected success rate across arbitrary experimental objectives.
Nor do these results report completed physical experiments. The Fe coordination case, for example, does not establish measured electrochemical performance or validated coordination assignments.
The outcome being measured is computational admissibility, not chemical success.
Source: Capability-relative generation from scientific intent; Methods—Case construction and evaluation; Supplementary application cases.
Deployment should require more than a clean simulation report
For organizations developing AI-controlled robotic laboratories, Cognaptus draws a specific architectural implication: equipment access should be mediated through registered capabilities and validated laboratory-state transitions rather than unrestricted agent-generated commands.
A practical implementation would maintain explicit instrument contracts, preserve object identities and provenance, verify proposed workflows before dispatch, and retain diagnostics when validation fails.
This could improve the inspectability of permitted operations and allow modeled violations to be identified before equipment is commanded. Those are architectural possibilities derived from the framework, not measured reductions in accidents, operating costs, or experimental failures.
The principal deployment boundary is model fidelity.
A simulator cannot reject a chemical interaction, instrument fault, unexpected measurement, or scheduler conflict that its contracts and state model fail to represent. Live telemetry, recovery from physical failures, and actual equipment behavior remain outside the reported validation.
There is also a reproducibility qualification. The research record describes supplementary code and workflow artifacts but identifies incomplete dependency locks and generation settings, alongside the absence of a verified persistent public repository. These gaps constrain independent reproduction of the reported software pipeline.
Consequently, organizations considering deployment would still need physical acceptance testing, fault-handling validation, and evidence that their own registered capabilities accurately describe operating conditions. The paper supplies neither comparative performance estimates nor demonstrated financial returns.
Verification should precede authorization, not replace it
Li and colleagues establish a concrete computational approach for checking AI-generated laboratory programs against registered physical capabilities and evolving simulated states.
The four successful demonstrations justify further engineering evaluation of that approach. They do not justify treating a simulation pass as permission for unrestricted autonomous laboratory execution.
For an operator deciding whether an agent-generated procedure may control equipment, a clean validation report should answer one bounded question: Does this workflow satisfy the constraints that the laboratory model actually encodes?
Physical execution reliability and scientific validity require additional evidence.
That separation is the paper’s most consequential contribution to autonomous laboratory design: making operational admissibility independently checkable while preserving the distinction between a valid program and a validated experiment.
Cognaptus: Automate the Present, Incubate the Future.
-
Xiaobo Li and Luyao Ge and Xiaohui Li and Lulu Guo and Ming Mao and Jiwang Zheng and Wenting Guan and Xin Yang and Yi Luo and Jun Jiang and Linjiang Chen (2026). A computable representation of the physical laboratory enables verifiable workflows. arXiv:2609.03621. https://arxiv.org/abs/2609.03621 ↩︎