The durable value of a self-driving lab is not the model that picks the next experiment. It is the layer that refuses to run the doomed ones, and that can prove, afterward, why every automated decision was made. Most of the field is racing to optimize the first thing. The second is where the money leaks and where a regulator's questions land, and a better surrogate model closes neither gap.
Berkeley's A-Lab made the leak visible. Its 2023 autonomous campaign reported a 71% success rate, which means roughly 29% of its attempts did not yield the target (A-Lab, Nature, 2023). Those failed runs still spent reagents, robot time, and characterization. On real hardware a doomed synthesis costs exactly as much as a successful one, right up until the moment it fails. Scale that across a lab running around the clock and the waste stops being a rounding error. It becomes a line item.
The part the model can't reach
A larger surrogate or a cleverer acquisition function makes the search smarter. It does not make the chemistry safe. A proposed composition can be charge-imbalanced, or sit outside the Goldschmidt tolerance window, or put Sn(II) into humid air where it will oxidize. No property model "decides" not to run those. Something outside the model has to.
So when we built Autonomous Lab AI (the demo runs at veriprajna.com/demos/autonomous-lab-ai), we put the feasibility and safety decision in deterministic code that sits outside the agents. The optimizer proposes the next candidate. A digital-twin gate, enforcing five real published-chemistry checks, returns FEASIBLE or BLOCKED before anything reaches the robot: Goldschmidt tolerance factor, octahedral factor, charge neutrality, the Sn(II) oxidation hazard at process humidity, and the organic-precursor decomposition ceiling. Agents advise. Code decides.
One block, in full
Here is one block from a recorded run, so the mechanism is concrete rather than a slogan. The optimizer proposed (Cs0.04MA0.96)(Sn0.35Ge0.58Bi0.07)(I0.06Br0.43Cl0.51)3. The gate returned BLOCKED before synthesis and named exactly why: an Sn(II) oxidation hazard at process humidity, a tin fraction of 0.35 at 50% relative humidity, which oxidizes and is therefore both unsafe and doomed. The candidate never reached the robot. The system logged precisely what it prevented on that single decision: $105 of reagent and 2.33 robot-hours.
The gate blocking Experiment #75 before it ran: Sn(II) at 0.35 fraction in 50% humidity, flagged as unsafe and doomed, $105 and 2.33 robot-hours saved on this one decision, written to hash-chained record #111.
Across the full recorded campaign the gate blocked 38 infeasible candidates before synthesis, preventing $4,419 of reagent waste and 90.1 robot-hours, with zero infeasible syntheses executed. The closed loop reached a spec-meeting material at experiment 75, where random screening on the identical hidden objective would be expected to need about 1,491, roughly 20 times fewer. We are deliberate about that last number. The objective here is a physically-motivated synthetic benchmark, not real DFT or lab data, and the multiple is measured against reproducible baselines run on that same hidden objective, not an open-world guarantee. The value we lead with, the waste the gate prevents and the provenance it leaves behind, holds at any model quality.
The recorded run: spec met at experiment 75, 38 doomed candidates blocked before synthesis, $4,419 and 90 robot-hours saved, and 19.9x fewer experiments than random screening on the same hidden objective.
A better property model makes the search smarter. It cannot decide what is safe to synthesize, and it cannot prove why a decision was made. Those two things live outside the model, and they do not age out as models improve.
Why this is the durable part
Model quality is a moving target. Whatever surrogate is state of the art this year is beaten next year, and the advantage compounds for no one. The control loop, the deterministic safety gate, and the audit trail are a different kind of asset. They do not get obsoleted by a better foundation model, because they are not doing the model's job. They are the part that turns a clever optimizer into something a regulated lab can actually run and defend. That is the moat, and it is why we treat "agents advise, code decides" as an architecture, not a tagline.
Provenance is the second half of it. Every automated decision in the demo, the syntheses and the blocks alike, is written to an append-only, hash-chained record structured on ALCOA+ principles: attributable, legible, contemporaneous, original, accurate. The recorded campaign wrote 113 of them. To be precise about scope, this is ALCOA+ mapped, not IQ/OQ/PQ-validated against a client SOP. That validation is the engagement, not something we would claim from a demo. What the demo proves is that the provenance is real and inspectable, and that the FDA and EMA guiding principles for AI in drug development (FDA/EMA, 2026) ask for exactly this kind of attributable, contemporaneous record.
The exported audit: 113 hash-chained records, each block naming its real chemistry violation and the reagents and robot-hours it saved. ALCOA+ mapped and inspectable, not GxP-validated.
The reason a hash chain matters, rather than a plain log, is that it is tamper-evident. The demo has a Tamper test button. Edit a single stored record and the chain visibly breaks at that record, and the report says so in plain language: "Chain broken at record #2: tamper detected. The filed audit is provably altered."
A log you can quietly rewrite is not evidence. A chain that announces its own edits is.
After editing one record, the hash chain breaks at exactly that record and flags the filed audit as provably altered. Tamper-evidence you can watch happen.
Where we are honest about the edges
A few things this demo is not, because the distinctions matter. The lab is simulated behind a SiLA-2-shaped interface. There is no real instrument integration, no live Materials Project pull, and no hosted robotic lab. The optimizer is a Gaussian-process surrogate with target-directed (ParEGO) acquisition written in numpy and scipy; the production swap is BoTorch and Ax, and we say that rather than dress the demo up as the shipped engine. The loop absorbs the same 10 to 15% robotic failures a real one would, and it solved 9 of 10 benchmark seeds, not 10 of 10. We build the brain, the safety gate, and the provenance layer onto a lab's existing hardware. We do not pretend the hard integration work is already finished.
If you are standing up autonomous experimentation, the comparison we would actually like to make is narrower than the usual model-versus-model debate. When your optimizer proposes the next experiment, what sits between that proposal and the robot? Is the feasibility and safety call made by deterministic code a reviewer can read, or by the same model that proposed the candidate? And if a regulator asked you to prove why one specific run happened last Tuesday, could you produce a record that would survive the question? You can watch our version make those calls at veriprajna.com/demos/autonomous-lab-ai. The problem is industry-wide, and we would rather learn how your stack draws that line than argue about surrogate models.