Reach
A verified claim in the graph — with its verdict and full evidence trace — is packaged into a content-addressed contract: the claim, a predicted outcome, every trace edge with its provenance, and an execution request.
Every tool in your lab,
talking in one runtime.
WetHands is where the Peel runtime reaches out of the graph and into the world. A verified claim becomes a real experiment; the observed result comes back into the knowledge graph as evidence — under bounded, typed authority, with the terminus in control the whole way. Literature, structure, chemistry, pathways, the compute bench, and the bench instruments themselves — one governed console, one contract, one ledger.
Research prototype · PILOT-READY. Computational experiments and human-in-the-loop lab hand-offs run today; autonomous physical-robot dispatch is architecturally ready, not yet built. Stated plainly below.
Reach. Plan. Act.
Observe. Verify. Learn.
WetHands closes the scientific loop as a single governed pass. Nothing is fire-and-forget, and nothing enters the record it hasn't earned.
Plan
The planner composes the caller's intent only from the capabilities the chosen environment actually exposes. A missing capability is not improvised — it returns UNPLANNABLE with the exact gaps, recorded and refused.
Act
The plan is submitted to the environment's hands — a simulation, a human tech, or (by the same interface) a real instrument. Every step is a typed capability call, bounds-checked before it runs.
Observe
The terminus polls the executor and pulls the observed outcome back — confirmed, refuted, or inconclusive. Hand-off is never fire-and-forget; the runtime stays in control until the result is in.
Verify
Only a physical-grade environment returning confirmed/refuted may write evidence back — as supports_claim / conflicts_with edges from each witness to the claim. A simulation, or a shrug, is recorded but never becomes a fact.
Learn
The graph now holds the experiment's verdict, tied to the claim that predicted it, with the executor as provenance. The next reasoning pass walks that evidence like any other — the loop compounds.
What hands can do,
which hands are here,
and how to use them.
WetHands separates the affordance (what any set of hands can do) from the environment (which hands are actually available) from the plan (how a specific goal is composed from them). Swapping the bench from a simulation to a real robot is registering a dictionary — not rewriting the science.
The affordance model
Capabilities describe what hands can do, not what brand they are: aspirate, dispense, mix, heat, measure_absorbance, read_sensor, label. Each carries a machine-checked parameter schema — volume 0.1–10,000 µL, temperature 4–121 °C, wavelength 200–1000 nm — validated fail-fast before anything moves.
The environment registry
Every back-end — a simulation, a syringe-pump rig, a human tech, a cloud lab — registers itself as a dictionary of capabilities behind one protocol (capabilities · submit · check · collect). Each declares an evidence_grade. That grade is load-bearing honesty: only a physical environment can ever mint graph evidence.
The planner
The planner takes the caller's intent (say, a serial dilution) and composes it only from capabilities the chosen environment exposes. Never partial, never substituted, never guessed — a gap is an honest UNPLANNABLE with the exact missing_capabilities, recorded and refused.
The verified result becomes
a real experiment — under contract.
One module owns the contract and the whole lifecycle. Every dispatch, including every refusal, lands in an audit trail you can replay.
build_contract verdict + trace + every evidence edge with provenance + caller's predicted_outcome + execution request → SHA-256 content-addressed dispatch_handoff verify integrity → plan intent against the environment's discovered capabilities → PLANNED ? submit(contract, plan) : UNPLANNABLE / blocked → refuse & record check_handoff poll executor.check(ref) — the terminus stays in control collect_result re-verify integrity → record outcome → gate physical evidence into the floor list_handoffs the audit trail — every dispatch, including every refusal
Verdict-derived dispatch policy, deterministic: SUPPORTED → verified · UNKNOWN → exploratory (the experiment is how an unknown gets resolved) · CONFLICTING → blocked (never handed off). A trace edge with no provenance raises before anything is dispatched.
Three things almost
nobody else does.
Plenty of systems can tell a robot to pipette. The hard part is keeping the record honest when the robot — or the model driving it — is wrong. WetHands makes that structural.
Evidence-gated re-entry
A simulation can never become a fact. Only a physical-grade environment returning confirmed/refuted materializes graph evidence; simulated or inconclusive outcomes are recorded but never laundered into truth. The floor does not turn a pantomime, or a shrug, into a citation.
Bounded, typed authority
Every action is a typed capability with bounds checked before it runs, and the plan is composed only from what the bench actually exposes. There is no "try something" path. A capability the environment lacks is refused with its exact name — not approximated with one that looks close.
The terminus stays in control
Hand-off is not fire-and-forget. The runtime holds the contract, polls the executor, re-verifies integrity on the way back, and closes the loop itself. A result that doesn't match its content hash is rejected — the experiment cannot quietly rewrite the claim that ordered it.
The claim, plainly
The moat is not "we can drive a pipette." It is that a verified claim, a bounded plan, a real observation, and a graph edge are welded into one auditable contract where nothing untrue can survive the round trip. Symbolic control extends past the answer, all the way to the bench.
Drive every experiment
while it runs.
WetHands gives the runtime hands on all your tools at once — and keeps them under supervision the entire time.
Live status, not a black box
The terminus polls each running hand-off for status and pulls partial and final observations back on demand. You watch the experiment progress; you are never told "done" without the evidence to back it.
Long runs that survive restarts
The WetHands job lane runs detached experiments for up to 24 hours with disk-backed state under the workspace. Pull the plug on the console and the job — and its record — is still there when you come back.
wetware_job_start · wetware_job_status · wetware_job_output · wetware_job_cancel · wetware_jobsCancel, inspect, intervene
Any job can be inspected mid-flight and cancelled cleanly. Authority is bounded and reversible where it can be — the operator, or the gate, always has the last word.
Workspace-contained files
Everything the lab writes down — protocols, results, notebooks — is workspace-contained file operations under one root, so a run's whole paper trail lives together and travels together.
wetware_write_file · wetware_read_file · wetware_move · wetware_remove · list_workspaceThe instruments that
were never meant to connect.
The same console that searches PubMed, folds a protein, and walks a pathway also drives the bench — through one source contract. WetHands is what lets a literature finding, a structure, a variant, and a physical measurement sit in the same graph, reachable from each other.
The knowledge lanes
Nineteen public science services — literature, structure, genomics, variants, chemistry, pathways — every answer pinned to its database, accession, and URL, or it is an error.
The compute bench
Python beside the data — biopython, pandas, scipy, RDKit — for sequence work and cheminformatics on what the instruments fetched. Labeled honestly: process isolation, not a security sandbox.
The WetHands bench
Typed capabilities, a swappable environment, and the hand-off terminus — the lane that turns a verified claim into an experiment and an experiment into evidence.
Watch a claim
become an experiment.
A representative hand-off: a verified claim is contracted, planned against the bench, dispatched, and the outcome gated back — or refused. Replayed live in your browser.
WetHands terminus — a simulation can never become a fact.
Representative session in the shipped format. Step names (build_contract, dispatch_handoff, check_handoff, collect_result) and the evidence gate are the real terminus behavior; identifiers vary by run.
Exactly what runs,
and what doesn't yet.
The bar here is enterprise-grade honesty. WetHands is PILOT-READY: the architecture, the contract, the gate, and two working environments ship today. Physical-robot dispatch is architecturally ready and not yet built — and we say so on the page, not in a footnote.
Simulation environment
Full capability set, deterministic execution against a simulated bench (wells, volumes, absorbance from concentration). evidence_grade = "simulated"; collect() always reports inconclusive — it validates the plan, never the world.
Human-tech environment
The plan becomes a numbered work order (.md + .json) written to an outbox; a human runs it and writes back a result file that collect() parses. evidence_grade = "physical" — a confirmed/refuted result can mint graph evidence.
Real instruments
Any back-end resolves by dotted path (pkg.module:ClassName) behind the same four-method protocol — a cloud lab, a robot bridge, a syringe-pump rig. The seam exists; a production adapter for a specific instrument is a partnership build, not a claim we make today.
Verified terminus
The hand-off terminus ships with a focused test suite covering the contract, planning, refusal, integrity re-verification, and the evidence gate — the invariant that a simulation cannot become a fact is pinned by test.
The one thing we will not do
Describe this as driving a physical robot today. It doesn't — yet. What it does is the harder, more valuable part: make the path from claim to bench to evidence auditable and un-fakeable, so that when a real instrument plugs into the seam, nothing about the record has to be taken on trust.
Put your whole lab
on one runtime.
We set up pilot labs with research partners around a bounded question and a clear definition of success — the knowledge lanes, the compute bench, and the WetHands terminus on your machines, under one gate, one ledger, one source contract. If you have an instrument you'd like on the seam, tell us about it.
Research prototype. Not intended for diagnosis, treatment decisions, or replacing experimental validation.
Continue exploringThe WetHands paper