Litmus

A lab bench that records every experiment by itself. Gemini watches, listens and reads the instruments; Tiger Data keeps history you can diff, search and ask questions of, with proof for every claim.

Comment

Litmus: Git for the Lab Bench

Inspiration

When a result fails to replicate, the reason is usually boring. Someone used a different reagent bottle, tap water instead of distilled, or skipped a step.

Those details almost never make it into the notebook, because writing everything down while your hands are full is impossible. So when one run looks too good, there's nothing to check it against except memory.

Software engineers solved this decades ago. Every change is committed, every line can be blamed, and any two versions can be diffed.

We wanted that for the lab bench, without asking a researcher to type a single commit message.

What It Does

You walk up to the bench and press Start Recording. That's the only button.

1. Set Up Any Experiment

You say what you're doing: "Hi, I'm Dr. Omar, this is Dr. Lena, we're titrating vinegar with phenol red."

Gemini titles the run, tags the researchers, and determines what's worth recording for that lab: steps, instrument readings, amounts, counts, qualitative observations, and the outcome.

Nothing is preconfigured for a specific experiment. If you say nothing, Litmus works from what the camera sees.

2. Watch, Listen, and Understand

Every few seconds, Gemini analyzes the bench cameras to:

  • Describe the scene and label researcher activities like pouring, mixing, and measuring.
  • Track which protocol step the researcher is on.
  • Read visible values from scales, thermometers, graduated cylinders, and other instruments.
  • Capture spoken observations like "that's two mL of base" or "it's turning pink."
  • Filter out unrelated small talk and use whichever microphone captured the audio best.

3. Turn Every Observation Into a Commit

Every event is timestamped, tagged with its provenance (measured, reported, or inferred), linked to the frame or audio it came from, and hash-chained to the previous event.

When the run ends, the record is sealed with a digest of every reading and frame. Change a single byte, and verification fails at the affected commit.

4. Log: Replay the Experiment

Every run opens in an editor-style player, with video synchronized to tracks for protocol steps, speech, Gemini's observations, commits, and sensor readings, all controlled by one playhead.

5. Data: Every Run Becomes a Dataset

Each experiment becomes a table, with one row per run and one column per measurement.

Every cell links directly to its evidence receipt, and the entire dataset can be exported to CSV with one click.

6. Diff and Verdict: Find the Confound

Pick the run that looks like a breakthrough. Litmus compares it with the control across every recorded variable, evaluates each difference against the variation normally seen in identical reference runs, and checks the researcher's proposed explanation against the measurements.

Instead of relying on memory, researchers can investigate what actually changed.

7. Ask Your Lab

A chat interface built around the experimental record lets researchers ask:

  • "Why was Method B different?"
  • "Graph the results for a paper."
  • "Write the methods as they actually happened."

Every answer shows how many evidence receipts support it, numbered evidence cards containing the actual frames, and a Why This Answer? trail showing the lookups it ran.

How We Built It

Hardware: The Lab Station

We built the station around a Raspberry Pi 5 with:

  • A 7-inch touchscreen kiosk
  • A USB webcam
  • A phone serving as a second camera
  • Every available microphone
  • A thermometer positioned within camera view

The station streams keyframes, audio, and readings through an offline-safe local queue, ensuring a temporary Wi-Fi outage doesn't lose a run.

AI: Google Gemini on Vertex AI

Gemini handles perception, transcription, and reasoning across the experiment.

  • Gemini 3.8 Flash: Sets up experiments from spoken introductions and camera frames, describes the scene, labels activities, tracks protocol steps, and reads instrument values.
  • Gemini 3.5 Flash-Lite: Transcribes narration, filters for experiment-relevant speech, and reads the thermometer.
  • Gemini 4 Argon: Generates verdicts and lab reports and powers Ask Your Lab through eight function-calling tools over the experimental record.
  • gemini-embedding-001: Embeds every commit for semantic search.

Database: Tiger Data

Tiger Data stores the complete experimental record:

  • A hypertable containing every reading, ingested using COPY.
  • A real-time, one-second continuous aggregate powering the timelines.
  • An append-only, hash-chained event ledger with per-run advisory locks.
  • pgvector with HNSW indexing and full-text search, fused through reciprocal rank fusion for semantic retrieval.
  • Append-only analyses cached against chain heads, so asking the same question about the same record never triggers a second model call.

Web and Infrastructure

  • Frontend: Next.js 16 on Vercel, with an offline snapshot fallback.
  • Backend: FastAPI worker running in Docker on a VPS.
  • Station service: Python service managed by systemd on the Raspberry Pi.

Rules We Enforce in Code, Not in Prompts

We designed Litmus around a simple principle: AI can perceive and explain, but code owns the numbers and the record.

  • No model-invented numbers. Gemini can read a number from a display, stored as an inference with its source frame. Every aggregate, difference, and normal-variation band is calculated by code.
  • Every claim cites evidence. A validator rejects citations that don't exist in the experimental record.
  • Four verdict labels only: Observed, possible explanation, contradicted, and missing evidence. No probabilities anywhere.
  • Provenance on everything. Every value is identified as measured, reported by the researcher, or inferred by AI.
  • Missing means missing. An unavailable sensor is explicitly marked as missing, never estimated.

Challenges We Ran Into

1. Our Hardware Plan Fell Through

On the day of the hackathon, we had no ADC or Grove HAT, so our original breadboard sensor setup wasn't possible.

We rebuilt around the hardware we had: cameras, microphones, and a thermometer in view. Moving perception to Gemini made the product significantly more general than our original sensor-dependent approach.

2. Avoiding Overfitting to One Experiment

Our first version was essentially a titration recorder. We rewrote the setup process so Gemini dynamically declares which measurements matter for any experiment a researcher describes, while code still owns every calculation.

3. Never Missing a Word

The spoken introduction is processed while the researcher continues talking. To prevent narration from being lost or associated with the wrong protocol, we serialized setup per run and made narration wait for the correct protocol.

4. Making "Normal Variation" Honest

The difference between two runs varies approximately 1.4 times more than a single run does. Ignoring this distinction tripled false alarms between runs that should have looked identical.

We corrected the comparison logic to account for variation between runs rather than treating them like isolated measurements.

5. Handling Database Latency

At roughly 80 ms per database round trip, individual writes created a backlog. Coalescing the station's queue and bulk-loading readings resolved the bottleneck.

Accomplishments We're Proud Of

  • One button. Walk up, press start, talk, and work. The record writes itself.
  • Experiment-agnostic recording. Litmus isn't a titration app. Describe any lab, and Gemini determines what to watch for.
  • Traceable evidence. Every number and sentence can be traced back to the frame, audio, or reading it came from.
  • Tamper detection. Editing a single database value turns the run's "record intact" badge red and identifies the exact commit that changed.
  • Validated performance. Our validation suite achieved:
    • Color changes detected within 1 second.
    • The planted confound surfaced as the top difference.
    • Only 2 false alarms across 110 same-protocol comparisons.
    • 100% of AI-written claims traceable to evidence.

What We Learned

  • Sometimes the most valuable thing AI can say is "this wasn't measured."
  • Models are great perceivers and bad bookkeepers. Let them see, read, and explain, while code handles the arithmetic and ledger.
  • Provenance is a design problem. A value read by a sensor, reported by a person, and inferred by a model must look different on screen.

What's Next for Litmus?

Multi-Bench Labs

Compare runs across stations and researchers, with branches for protocol variants and collaborative experimentation.

Live Coaching

Have Gemini flag skipped steps or incorrect reagents during the experiment, not after the run is over.

Bringing Reproducibility to High-Stakes Research

We're particularly interested in environments where hidden confounds can cost millions, including cell culture, where incubator temperature, reagent lot, and passage number matter, and preclinical research, where an unnoticed difference can remain hidden until Phase III.

Litmus makes experimental work as traceable as software, so researchers can spend less time documenting what happened and more time understanding why.

Built With

Share this project:

Updates

Submission history