Run the experiment
Computational experiments — sequence analyses, structure comparisons, screens over retrieved records — run as jobs with defined inputs and retained outputs, not as one-off text.
Tools that cite their sources.
Hands that do the work.
Perslis is the science runtime that surrounds Peel. It is a working pilot that connects a reasoning session to the scientific record — literature, molecular data, pathways, and computation — under one contract: every result names the database it came from, or it is an error. What comes back can be checked, and acted on.
A working pilot used in our own research. Not a hosted service; no biomedical findings are claimed here.
5tool layers
35grounded tools
22source-pinned databases
Counts from the pilot runtime and its tests against the public services it wraps. Scale figures, not accuracy or coverage claims.
Get your lab hooked up
and running.
No special equipment and nothing to rip out — we connect the systems your lab already uses. Literature, structures, variants, chemistry, and pathways through the services below; on the WetHands side, your LIMS, electronic lab notebooks, and instrument APIs. One governed console, every answer source-pinned.
PubMed Central
UniProt
AlphaFold DBInterPro
ClinVardbSNP
ReactomeQueried live through their public interfaces under the source contract. Names and marks belong to their respective owners; no partnership or endorsement is implied.
From the scientific record
to accountable answers.
The runtime organizes its access into five layers. Whichever layer produces a result, the same source contract applies.
- 01
Literature
Search and read PubMed, PMC, arXiv, and bioRxiv, plus the scholarly graph through OpenAlex and Semantic Scholar. Results arrive with identifiers, not summaries alone.
- 02
Molecular data
UniProt, PDB, and AlphaFold structures; Ensembl and NCBI sequences; InterPro domains; ClinVar and dbSNP variants; PubChem and ChEMBL chemistry — typed records under stable accessions.
- 03
Computation
Analyses run with standard scientific Python over the retrieved records, in a separate worker process, so a computed answer stays tied to the inputs it used.
- 04
The source contract
Every tool result carries its source: database, identifier, resolvable URL, and retrieval time. A result that cannot pin its source is returned as an error, never as an answer.
- 05
Knowledge and pathways
KEGG and Reactome provide pathway context; a shared glossary keeps terms and mechanisms anchored to curated references.
Databases are queried live through their public interfaces; the runtime keeps no mirror of them and adds no facts of its own.
Reading the record is half of science.
WetHands does the other half.
WetHands is the runtime’s actuation lane — the part that acts. Experiments run as managed jobs: started from a reasoning session, executed in isolated workers, monitored, cancelable, and retained with their inputs, so doing the work carries the same accountability as reading the record.
Hands that hold on
Long experiments detach into background jobs with disk-backed state. A run survives session restarts and reports its progress honestly for up to a day.
Connect your systems
The same job contract is the integration surface for your infrastructure: lab information systems, instrument and wet-lab automation APIs, data platforms. Your API on one side, the source contract on the other.
Acting stays honest
A job that cannot say what it ran, over which inputs, with what outputs, is a failed job. Actuation gets no exemption from the contract that governs retrieval.
Computational experiments run in the pilot today. Wet-lab and instrument connections are integration work we scope with each partner — the contract is ready for them; no autonomous laboratory is claimed here.
Pinned to the record,
or returned as an error.
Pinned or refused
A missing source is not a formatting problem; it is a failed result. The unpinned path fails closed, so an unsourced claim cannot flow downstream as knowledge.
Generation cannot verify itself
Language models operate the tools and express results; they do not decide what is supported. Evidence standing comes from the record behind the identifier — the same separation Peel enforces symbolically.
Honest failure
Rate limits, missing records, and empty answers return as what they are. An unavailable source reads as unavailable, not as an eloquent guess.
Bounded execution
Tool calls respect per-service request limits and defined budgets. Being considerate of public scientific infrastructure is part of the design, not an afterthought.
Retrieval brings evidence.
Knowledge still has to earn it.
The runtime is how a reasoning session reaches the world; Peel is how what it finds becomes knowledge. A retrieved abstract or protein record is evidence to examine — connected, typed, and open to contradiction checks — not text to paraphrase.
One discipline, two enforcement points
Peel returns unknown when the graph lacks a relationship; the runtime returns an error when a result lacks a source. Both refuse to let fluency stand in for support.
A system that does science
should improve like science.
The runtime sits inside our evolution program: a Darwin Gödel Machine–style loop in which the system proposes improvements to its own tooling, and a held-out verdict — one the proposer cannot see or game — decides what is promoted. Its purpose is the same as the source contract’s: progress you can verify, not progress that flatters itself.
Selected for honesty
Self-improving systems drift toward whatever their reward measures. That is exactly why verdicts here are held out and outcome-grounded: a change ships only after it provably does better science.
Built as a pilot.
Tested against the live record.
The runtime ships with mocked and live test suites and is used in our own research over the Model Context Protocol (MCP). Extending it with domain partners — and evaluating it against expert reference answers — is the validation path we are pursuing.
Research prototype. Not intended for diagnosis or treatment decisions.
The runtime, running.
A short, unedited capture of the science loops driving a research cycle end to end under one source-pinned contract. Recorded on a research prototype.
The science runtime
Science loops running the research cycle end to end under one contract.
Continue exploringTools