Lab Voice
Labs buy pipetting robots and then barely use them, because using one means writing code.
Core trick
Claude emits a structured plan via forced tool call, while deterministic validators check each instrument's declared capability contract before any run needs spoken confirmation.
Description
Labs buy pipetting robots and then barely use them, because using one means writing code. So scientists who can't code pipette by hand for hours, and a machine worth thousands sits idle. That's the gap between the person who knows the biology and the machine that could run it.
Lab Agent closes that gap with voice, safely. A scientist says "run an ELISA on today's plasma samples." Claude resolves that into a structured Plan through a forced tool call. It never writes robot code. A deterministic compiler expands the Plan, and deterministic validators, not the model, check SOP completeness, reagent expiry, well capacity, and what each instrument declares it can do. Nothing executes until a human confirms out loud, with assumptions read back.
The core idea is capability contracts. Each adapter declares its limits, and routing falls out with no special-casing. A microliter ELISA is accepted by Opentrons and refused by an acoustic Echo. A nanoliter dilution compiles for the Echo and is refused by Opentrons. Same workflow, same validator, opposite verdicts.
The hard problem isn't getting an AI to say yes. It's getting it to say no, with a reason, before a reagent is wasted or a hazard created.
This runs on a real Opentrons OT-2.
README excerpt
# Lab Agent
Turn a scientist's spoken request into a **validated, robot-agnostic protocol** — and
route it to the instrument that can actually run it.
```
Voice pipeline → Lab Agent API → Workflow IR → Robot adapter → Simulation
(this repo)
```
Your teammate owns speech (STT → Claude → TTS). This repo is the middle: it takes a
transcript, resolves intent with Claude, compiles a platform-independent workflow,
validates it against deterministic safety rules and each platform's declared capabilities,
and simulates the run — with a human confirmation gate before anything moves.
The core principle: **free-form model output never touches hardware.** Claude proposes a
*Plan*; deterministic code compiles, validates, and simulates it. Claude resolves
**intent**; the systems of record resolve **fact**.
> **Status:** backend, API, web console, and both demo scenarios are complete and tested.
---
## Two-layer IR (the key design choice)
| Layer | Produced by | Nature | File |
|-------|-------------|--------|------|
| **Plan** | Claude (tool-forced) | semantic, carries `assumptions` + `missing_fields` | `app/models/plan.py` |
| **Workflow (Ops)** | deterministic compiler | fully-specified, platform-independent primitives | `app/models/workflow.py` |
Adapters consume **only** the Workflow. Each adapter *declares its capabilities*, and the
validator reconciles the workflow against them — that declaration is what makes the system
genuinely robot-agnostic ra