Contents
Cybersecurity
CISO-as-a-service consulting: posture, remediation roadmap, ongoing support.
Discover →
Linux Services & Systems
Domains, hosting, PEC, email infrastructure, network services and Linux systems. Open Source infrastructure support and management.
Discover →
On 27 August Anthropic opened the research preview of the Model Hardware Standard, a specification for letting an agent operate the physical instruments of a lab or a production line. Access goes to a first group of research labs and manufacturers, by application.
The project began as a collaboration with HHMI Janelia Research Campus. It is stated to be model-agnostic, it works with any device that has a programmable interface and a harness reaches it through standard protocols such as MCP.
Alongside the announcement came five accounts written by the partners, with measured figures. That is the part worth reading.
The driver and the primitives
The central piece is a standardised driver. It exposes a small set of primitives (read to get a quantity such as temperature, write to set it) and makes every device discoverable in a common format, so instruments and agents find each other on the network without a translator written for each pair.
Above the primitives sits the part designed for the model. The information that usually lives in a paper manual or in the head of whoever runs the machine, the weight of a robotic arm for instance, is written into the driver as natural-language tags. From those tags the driver generates a reference file with what the instrument measures, what can be adjusted and which safety limits are enforced.
Control of the hardware then goes through three mechanisms: MCP, a CLI and code files. The last one is what matters in operation: long runs, or operations faster than the model could reason about step by step, get chained into a script, and from there the instruments proceed on their own.
QuEra, relocking the laser
The best documented pilot comes from QuEra Computing, which builds neutral-atom quantum computers. The titanium-sapphire laser that manipulates the qubits has to hold its frequency to roughly one part in a trillion, and when it loses that, quantum operations start to fail.
The starting point is measured. Before MHS a group of four people, a laser-systems engineer, a software engineer, an algorithms specialist and a tester, had spent several months writing a bespoke recovery script. That script reproduced step for step what a person does at the bench, and it worked 58% of the time in about 150 seconds per attempt. Manual recovery takes 5 to 10 minutes.
The loop they rebuilt it with is interesting for how it is organised: four roles, each a fresh instance of Claude. One proposes a hypothesis for making recovery faster or more reliable, one writes it into the script, one runs it against the live laser logging every step and one reads the log and decides what to change. The cycle ran for hundreds of passes, unattended, overnight. It is one of the shapes you can give a cycle, here applied to a physical instrument.
By morning recovery was down to about six seconds with 96% success on the development run. In the blind test that followed, against the same randomised set of induced disturbances and with no agent involved, the script relocked 695 times out of 700, 99.3%. The hardest disturbances take 10 to 14 seconds, the simplest 0.9 to 5.4.
The gain comes from a structural rewrite: Claude turned the linear sequence into a decision tree that reads the instruments and builds conditions from what they show. If the frequency has barely moved, almost none of the laser’s controls would change anything, so the script touches one or two and leaves the rest alone.
They then pointed the agent at the quality of the lock, which is set by 12 interdependent PID parameters. The tuning done by the specialist measured 15.7 mV of residual error. Over 363 experiments and 16 unattended hours Claude brought it to 1.55 mV, roughly ten times quieter on the measure it was optimising against. To verify that independently the specialist retuned the same laser from scratch by his own method, without seeing the agent’s result. The two sets of parameters then went to a phase noise analyser.
The limits QuEra states are just as precise. When something went wrong with the physical hardware Claude could not diagnose it, because its understanding of the rig is programmatic rather than physical. And it often stopped to wait for human confirmation before actions it judged even slightly risky, so some experiments sat paused all night. The team’s comment on that second point: “an overly cautious agent is preferable to one that is not cautious enough”.
Genentech, where the model stopped
Genentech used MHS to automate the BCA assay, the measurement of total protein concentration in a sample, which requires coordinating a liquid handler, a robotic arm and a microplate reader.
The task given to Claude was to optimise the pipetting flow rate for two liquids with different properties, water and bovine serum albumin, minimising the gap from a transfer performed by an expert on the same plate. The model arrived at about 140 µL/s for water with 0.016 RMSE and 10 µL/s for BSA with 0.181, values the company’s automation experts confirmed were reasonable for that setup. Along the way it recovered on its own from tip pickup failures and fluid detection errors.
The stopping point is documented with the same care. Viscous solutions form bubbles and bubbles distort the aspirated volume, throw off the level sensors and corrupt the final optical reading. Faced with a bubble error, Claude’s instinct was to retry in the same well with different parameters, which agitates the fluid further and produces more. It did not know the physics of the failure. Once told the error came from bubbles and that it had to move to a clean well and reduce mixing cycles, it held that context for the rest of the run and the lesson was codified into reusable liquid handling skills.
Carnegie Mellon, the six induced faults
The Carnegie Mellon pilot carries the only published evidence on safe behaviour.
The setup combines a CyBio FeliX liquid handler, a Varioskan LUX reader, a Spinnaker arm and monitoring cameras, spread across three computers with incompatible interfaces: the arm is driven by a scheduler that watches a directory and reads job files instead of exposing an API, the liquid handler only through ActiveX/COM scripting on Windows and the plate reader has no programmatic interface at all, only an on-screen GUI. Writing the drivers from scratch plus the orchestration layer took about eight hours, against the several weeks a vendor-built setup usually takes.
The check: they induced six fault conditions, missing plate, rotated plate, reader busy, disconnected camera, unreachable device and active emergency stop. All six were blocked before any device moved.
Then the dose-response curve. The first run, with a top concentration of 200 µg/mL, saturated and produced too poor a fit, R² below 0.9. The agent discarded the plate and reran on a fresh one with the range compressed to 100 µg/mL, accepting the result without human intervention. Overall, experiments roughly three times faster. The drivers written for these instruments will be published.
Janelia and Tetsuwan, the shared state
At Janelia the two-photon microscopy rig described by Virginie Ruetten required seven programs from different vendors launched in a fixed order, with the detectors in MATLAB and the cameras elsewhere. MHS replaces them with a single state dictionary in shared memory, readable by any process that attaches to it. The practical effect she reports is that integration cost stops scaling with the number of devices: adding a new camera used to be a multi-day job, now it is minutes. The shared dictionary idea comes from Arco Bast of the Spruston lab, and it is where MHS started.
Tetsuwan Scientific grafted MHS onto its own ResearchOS platform for a qPCR on pollution in San Pedro Creek, California. Two things stand out. Protocols stay hardware-independent: you write “spin at 15,000 rpm for five minutes” without naming a centrifuge and ResearchOS queries the network to find a compatible one and convert the value into that machine’s parameters. And when a camera detected bubbles in the master mix inside a tube held by the robotic arm, the system scanned the lab for other connected devices, proposing over Slack to move the tube to a centrifuge and spin it gently.
On tuning their own compiler they measured 9,143 dispenses, 300 transfer types and 1,508 conditions across four liquids, ending up predicting multi-dispense precision about 12% more accurately than the manufacturer’s specification, winning 31 runs out of 45 with a sign test at p ≈ 0.001.
In the Baker and Pinglay labs at the University of Washington, Zihao Song connected six instruments in under a week, drivers included, with a robotic arm built on LeRobot, Apache-2.0 and 27,041 stars as read on 29 August.
The standards that already existed
The field is not empty, and it is worth knowing what is there.
For lab instruments SiLA 2 has existed since 2018 and is maintained. The work lives on GitLab, under the SiLA2 organisation: sila_base holds the feature definitions, the framework protobufs and the XML schema, and the implementations cover Python, C#, C++, Rust and Java. As checked on 29 August the latest commit on sila_csharp is from 27 August and the one on sila_python from 9 August, which is the implementation that installs from PyPI as sila2. Outside the official organisation there are other libraries, for instance unitelabs-sila from UniteLabs, MIT, at 0.9.4 released on 30 July. On the industrial side OPC UA has open62541, MPL-2.0, with commits from that same 29 August.
Stars on these repositories run between ten and twenty, which is a low number and says little: these are projects followed by the people who build instruments, not by a general developer audience.
The difference MHS is trying to introduce is therefore not one more transport on an empty field. It is that the device descriptor is written to be read by a model, with the physical constraints and safety limits inside it, rather than only to let two machines talk.
What cannot be judged yet
The specification is not public. The announcement says the standard will be open sourced after the preview, and as checked on 29 August there is no official repository under the anthropics organisation. What circulates on GitHub are third-party projects born in reaction to the announcement, one of which openly states it is built while waiting for the real spec to land.
So what is missing, for now, is the text of the standard, the licence it will carry, a conformance suite and a written security model. On the limits the driver enforces we know they exist and that at Carnegie Mellon they stopped six faults out of six, which is the right thing to test but is also a small sample. We will see how many fault types they hold against and with what stated guarantees.
What we think
There is a pattern that repeats across every pilot and looks like the most solid part: the agent is there to produce a deterministic artefact, then it leaves. At QuEra the end product is an inspectable script that runs in production without an agent, and the 99.3% is measured in exactly that configuration. At the laser, Claude packages into code files what it learned aligning the mirror. At Genentech the lessons about bubbles become reusable skills. It is the opposite of the model where the agent stays in the loop forever, and it moves the cost of reasoning upstream, once, leaving something in operation that can be read and versioned.
The second thing is the blast radius of an error. When we wrote about harness and sandbox the worst boundary to cross was the host kernel and the answer was moving it onto a microVM. Here an error moves an arm, crashes an objective or burns hours of sample preparation. No level of software isolation contains that. Containment has to sit in the driver, meaning in the declared limits and the pre-emptive blocks like Carnegie Mellon’s six, and in the human checkpoints we wrote about in security and governance of the agentic loop. On that, QuEra’s note about the overly cautious agent suspending the experiment all night is the real trade-off, not a defect to be fixed in a hurry.
The third concerns how honest the accounts are, which is a lot. Genentech publishes the point where the model made things worse by retrying in the same well, QuEra publishes the 58% it started from and says the agent cannot diagnose physical hardware. After the METR investigation into the OpenAI and Hugging Face incident, where the subject was precisely what agents do outside their assigned task, accounts that state where the system stopped are worth more than ones that only state how far it got.
For anyone working on instrumentation, the practical point is already assessable without the spec: Carnegie Mellon’s eight hours started from a plate reader that exposes only a GUI and Zihao Song’s six instruments were connected in under a week including writing the drivers. If those times hold outside the pilots, the cost line that changes is integration more than the model.