Physical AI for biology, built by scientists.

The judgment that decides whether an assay worked, why it failed, and what to run next has lived in scientists' heads and hands – tacit, often unwritten. This site is about encoding more of it into automation, while keeping scientific judgment, controls, and evidence at the center.

The Laboratory Intelligence Layer

There's a layer missing from biology, and we've just reached the moment it can be built.

For decades, lab automation has given us better hands – faster pipetting, more throughput, robots that execute the steps you hand them. What it may not have given us is the mind: the judgment that decides whether an assay worked, why it failed, what to run next, when to trust a result and when to throw it out. That judgment – call it the laboratory intelligence layer – has often stayed human. It is a bottleneck in biological R&D, and a reason automation has underperformed.

That layer is tacit. It doesn't live in protocols or papers. It lives in the heads and hands of domain experts, built from years at the bench with valuable parts not fully articulated.

We've crossed an inflection point. Language models and modern automation tools can help domain experts express more laboratory judgment in executable form. In exploratory prototypes, I have used agents to coordinate bounded portions of omics workflows under defined controls and human oversight. That work asks a narrower question: which decisions can be encoded, tested, and gradually trusted, and which still require a scientist?

This is the moment. The time to encode expert judgment into autonomous execution is now – not because the robots finally exist, but because the experts can finally teach them.

Once that layer exists, the rest follows. Senior-scientist execution, reproducible, at scale. The cost of running biology collapses toward the cost of the chemistry itself. The scarce thing – expert time, human creativity – is freed for the work that matters: understanding nature, and engineering it for good.

The hardware is here. The models are here. The thing missing was the intelligence layer – and the only people who can build it are the ones who already hold it.

Where the Robots Fail – and What I Teach Them

The claim: the laboratory intelligence layer is tacit, and the person who holds it can encode it directly. Here's the specific version – the work, where automation breaks, and how the tacit becomes transferable.

A redacted workflow

Take a low-input epigenome workflow – reading chromatin state from vanishingly small amounts of material, at a sensitivity that gives a direct readout of epigenetic reprogramming.

Consider a measurement layer that stays challenging even for the reprogramming and longevity field. The recent, celebrated result where AI-designed factors sharply raised reprogramming-marker expression was validated by markers, morphology, DNA-damage repair, and karyotype – the functional consequences. The direct epigenetic state, the substrate being reprogrammed, is the harder readout. It goes missing for a plain reason: it's a tacit skill, hard to staff for.

That readout is what I build. It's hard by hand even for an expert; teaching a robot to do it at the scientist's bar is the real work – not "automate a kit," but recapitulate a technique few labs run at all.

Where the robots fail, and why

Here's the part that isn't in the protocol. At low input there's little margin, and passing QC or not often comes down to calls made by feel:

• pipetting height – relative to the meniscus and the well bottom; too high shears or splashes, too low misses or scrapes
• blowout volume, and the timing of it
• aspiration and dispense speed – different for a viscous mix, a bead slurry, or a fragile low-volume sample
• the dip, the touch-off, the swirl, the mix pattern
• timing, and on-ice vs. room-temperature handling at the right step
• real-time volume adjustments – adapting to input constraints per step
• sample-type-dependent chemistry updates

Little of this is written down – I didn't write it down myself, and a camera may not catch it. Yet it's often what clears a senior scientist's bar. It's why lab automation may run the steps faithfully and still get worse data: the steps that mattered weren't on the page. The one making the call is the one who can encode them.

How you encode it: instrument the delta

A manual gives you the official protocol, not the real one. The real one comes from instrumenting the gap: run the standard protocol, run it my way, measure both the same, and let the decision rule fall out of the deviations that improve the data. The scientist is both builder and benchmark – a controlled study of my own technique, pointed inward. That's how "I get good data" becomes "the platform does."

Why this is the moat

The reason this is hard is the reason it's defensible. Hand someone the protocol and the output, and they'd still struggle to reproduce the data – because the part that makes it work isn't in the artifact. It's in the hands.

That non-transferability is likely biology's moat; I think of it as the problem: it's why a great scientist can be a single point of failure, why the knowledge leaves when they do, why programs are difficult to scale past a few pairs of hands. So the moat isn't the protocol. It's the judgment behind it – and judgment can now be encoded.

The Trust Layer

Autonomous science isn't really a robotics problem. It's a trust problem – and that's a more hopeful thing to be.

Hardware for automating substantial portions of laboratory work has existed for years: liquid handlers, precise and patient, already available. The harder problem is the judgment around execution – what to observe, when to intervene, and what evidence is needed before a workflow can run with less supervision.

Judgment died in translation

For most of automation's history, encoding an expert meant handing their judgment to an engineer who didn't hold it. The part that made an assay work rarely survived the trip. It lived in a pair of hands and died on the way to the machine. What changed is who does the encoding: the person with the judgment can now hand it to the machine directly, with no one in between to lose it.

What the cloud labs taught us

Years ago, a version of this went all the way: put the whole laboratory in the cloud – ship your samples, a facility somewhere runs them. A beautiful idea that didn't so much fail as reveal the real constraint. Someone close to that work named it plainly:

There is no way to decouple scientific judgement from the execution of experiments – there is always more going on in an experiment than can be captured by a finite set of instrument readings. – Stefan Golas, on what happened to cloud labs

That is the whole lesson. Separate the judgment from the bench and it leaks out; no amount of remote precision catches it. So you don't route around the scientist – you encode the scientist, and run that judgment where the experiment actually happens: on the bench, in context.

Trust is the gating variable

This is why I keep coming back to Waymo. The car could drive itself long before we let it; what took the years was trust – the evidence that it could be left alone. Only then did the driver come out of the seat.

A lab is the same. You can't take the senior scientist out of the loop until the encoded judgment earns the trust to run unwatched – which is what built by scientists really buys: the one who sets the bar is the one who builds to it. When that trust holds, the ratio inverts – not one person per role, but many machines and one scientist overseeing them all.

What becomes possible

The judgment compounds. Every assay you encode leaves something behind – the failure modes, the calls that separate good data from bad – so the next one is cheaper to teach, the way every mile deepened the self-driving model. Follow it out and the destination isn't a faster service; it's a whole facility running on encoded judgment, with the scientist doing the thinking, not the pipetting.

None of it turns on better robots. It turns on trust – and trust is earned by the hands it's meant to replace.