Inspiration
Lab robots run Python now, and more and more of that Python is written by language models, because most biologists never learned to code. Before a run you can test the script in the robot's own simulator, but the simulator checks the physics: the arm can reach, there is a tip on, the well will not overflow. It has no idea what the liquids are. It will pass a serial dilution at half the volume asked for, or a used tip carrying patient samples back into the shared master mix. People who run these robots say it plainly: for code, an agent can test and correct itself; for a robot protocol, "there is no equivalent" (a practitioner on labautomation.io). We are two biology students, and the first thing you learn at the bench is to change your tip. We wanted to build the test suite lab-robot protocols never had, and to let an open model use it the way a coding agent uses tests.
What it does
You say what should end up in every well. Provette turns the request into a plate map, what every well should hold at the end, for you to check and approve. Then NVIDIA Nemotron writes the Opentrons OT-2 protocol, and Provette proves or disproves it:
- it runs the protocol in the Opentrons simulator and records every aspirate, dispense and tip change, checked against Opentrons' own analysis of the same run;
- it replays that record and follows every microlitre through every tip and well;
- it answers the questions a scientist cares about: does every well match the plate map to the microlitre, did a sample end up in the bin, did a used tip carry something into a stock, will a tube run dry, is every volume within what the pipette can measure;
- twelve rules, each resting on a published source (a kit manual, a lab guideline, a paper), catch what a well can hold and still be wrong: carry-over, unmixed draws, order of addition, missing controls. Every finding names the step, the line, the wells and the fix. Nemotron reads the report, repairs its draft, and only a protocol that verifies is handed over, with a prep sheet for the bench and a 2D and 3D replay of the deck. You can also check a protocol you already have, with no model involved, and teach Provette a new word or a new rule through a form. Provette checks the logic of a protocol, not the physics, and every report says so.
How we built it
The checker is ordinary, deterministic Python on top of opentrons 8.8.2: a tracer that records the run, a ledger that replays it, a plate-map verifier and a rule engine. The model is never the judge.
The agent is Nemotron 3 Super 120B on Nebius Token Factory, with tool calling and reasoning on. Its tools are the plate map, a list of real labware, calculators for the arithmetic, and write_protocol, which runs every check on each draft and sends the report back. Nothing is trained: Nemotron is prompted, given tools and held to the checks. We fitted the loop to Nemotron from NVIDIA's own model cards and chat templates: a reasoning turn cut at its budget is closed and continued, the reasoning is sent back inside the tool loop, and each model runs at NVIDIA's recommended sampling settings. Every check can also run in its own disposable Token Factory Sandbox.
The product is a FastAPI service with React and TypeScript pages; the deck replay is drawn with three.js through react-three-fiber. It runs on one small machine on Fly.io.
Every number below is measured, and the Methods page recomputes each one from the evaluation's files when it loads. Nemotron on Token Factory, verified on its own (first draft) → with Provette in the loop, and the cost per verified protocol:
- Super 120B, 34 everyday requests: 1 of 34 → 31 of 34, $0.044 each
- Super 120B, 15 harder requests: 2 of 15 → 12 of 15, $0.097 each
- Nano 30B, 34 requests, best of 3: 0 of 34 → 25 of 34, $0.196 each
- Nano 30B, 15 harder requests, best of 3: 0 of 15 → 8 of 15, $0.287 each
The checks themselves: 34 correct protocols verify across 986 wells, and none verifies against the wrong plate map. Of 228 planted bugs that change what a well holds, every one of which the Opentrons simulator passes, Provette flags 212; the 16 it misses are samples swapping wells on a plate map that leaves positions free. We built it with AI coding agents, the same way Provette works: we set the goal, wrote the checks the work had to pass, and reviewed what came back.
Challenges we ran into
- Knowing the rules was not enough. We wrote all twelve rules into Nemotron's prompt as instructions, with no checker: 7 of 34 protocols verified, and 19 of the 29 drafts that ran broke a rule the model had just been told. It is the loop with real feedback that carries the result, not the knowledge.
- A rule that cries wolf is worse than no rule. We ran every rule over the correct protocols, over the agent's drafts and over the public Opentrons protocol library, and read every hit until it stopped firing on things that are fine. One tier of the pipette-range rule was deleted for exactly that.
- Reasoning budgets. The smaller model often reasons until it runs out of tokens before the loop closes. We close a cut thought and let the model continue, and run Nano best of three with the checker choosing.
- Trusting our own replay. If the ledger is wrong, every finding is wrong. Our record of every action is checked against Opentrons' own analysis of the same run, and they agree on 788 of 788 public protocols.
Accomplishments that we're proud of
- An open model going from 1 of 34 verified protocols on its own to 31 of 34 with the checks in its loop, at under five cents per verified protocol.
- Every rule rests on a source we read, and is written so a biologist who does not code can read it, argue with it, and propose a new one through a form.
- Every number on the site is computed from files in the repository, and a test fails if a page and its file disagree.
What we learned
- A model with a test to pass behaves very differently from a model with instructions to follow.
- "Verified" has to mean something precise, and saying what was not checked matters as much as what was.
- How much of everyday lab practice (change your tip, mix before you draw, enzyme last, always a no-template control) is written down in kit manuals and papers, and how little of it a robot's simulator knows.
What's next for Provette: every well, proven
A practitioner's read of the findings, from someone outside the team; more of the techniques' not checked items turned into rules; time at temperature for thermocycler and cold-block steps; custom labware on the Check page; and a lab adopting proposed rules after watching them on real runs.
Who we are
We're Helen Henry (Tampere University, Finland) and Nyle Hussain (University of Glasgow, Scotland), two first-year biology students. We teamed up for the Nebius × NVIDIA Global AI Hackathon and built this across two countries and a two-hour time difference.
Log in or sign up for Devpost to join the conversation.