AI agents now do real genomics work end to end. The hard part is no longer writing the code; it is trusting the result.
Manuel Corpas
Senior Lecturer in Genomics, AI & Data Science · University of Westminster
Founder, ClawBio
Webinar · ClawBio × Genomic Intelligence · 24 June 2026
[0:30] Welcome. Thank you for joining ClawBio and Genomic Intelligence. I run the first 20 minutes, the framing. Then Benjamin and the GI team take over with the live work. One line to hold onto for the whole talk: agents can now write and run the analysis. The open question is whether you can trust what they ran. Everything I show is built around that single problem.
Today
The shape of the next 90 minutes
Manuel · ClawBio
The framing: what changed, why trust is the bottleneck, and the evidence.
Benjamin · GI
What the Genomic Intelligence models are and where they fit in a workflow.
Benjamin · GI
Live: GI skills running inside ClawBio on real, openly published genomes.
Everyone
Q&A, and an open call: build your own use case on the platform in two weeks.
For bioinformaticians, computational biologists, genomics researchers, and anyone building with AI agents in the life sciences.
[0:40] Quick orientation. I take the first 20 minutes to set up the problem and show you the evidence. Then Benjamin and GI show you the models and run live scenarios inside ClawBio. We close with Q&A and an open call: build something on the platform over the next fortnight and show us. Move fast here; the audience just needs to know where the handoff is.
Agents write, debug and run code; connect to files, databases and tools.
They plan multi-step analyses and adapt on intermediate results.
The researcher's role moves: producer → evaluator. Dozens of independently built systems have made the same move, from isolated prompts to multi-tool pipelines with runtime decision-making.
[1:30] Two waves. The first wave of LLMs in biology was retrieval: summarise this paper, answer a pathway question, pull structured data out of text. Genuinely useful, but incremental; it did not change what we could do, only how fast we read. The second wave is different in kind. Modern models write, debug and execute code, and when you connect them to a file system, databases and command-line tools, they plan multi-step analyses and adapt as intermediate results come back. The consequence: your job shifts from producing the analysis to judging it. Recent reviews catalogue dozens of these systems across genomics, single-cell, proteomics. This is a field-wide move, not one lab's claim.
Definition
Defining agentic genomics
An agent that plans and executes a genomic analysis end to end: it reads the data, chooses the tools, runs them, inspects intermediate results, and revises its own plan, with a human evaluating rather than typing every command.
Autonomy
Decides at runtime, not a fixed script.
Domain-constrained
Works through validated skills, not ad-hoc code.
Self-correcting
Diagnoses errors and re-plans.
Natural language
Directed in plain English, not code.
The test: perturb an intermediate result. A genuine agent changes its strategy; a fixed pipeline does not.
Grounded in Corpas, Fatumo & Guio, Agentic Genomics (Cell Genomics, in review). Worked example: a trio exome, BWA-MEM2 flags a bad index, the agent rebuilds it and resumes, unprompted.
[1:30] Here is the working definition, and it has teeth. Four conditions, jointly necessary: the agent decides at runtime; it works through a constrained library of validated skills, not code invented on the spot; it diagnoses its own errors and re-plans; and it is directed in natural language. If a system only satisfies some of these, it is something else: workflow automation, AutoML, or a chatbot writing scripts. The clean discriminator is the perturbation test: change an intermediate result and watch. A real agent re-plans; a fixed DAG carries on regardless. Concrete instance from a trio exome in our paper: BWA-MEM2 throws an incompatible-index error mid-run, and the agent diagnoses it, rebuilds the index and resumes, no human in the loop. That self-repair is the property, not the speed.
The thesis
From producing analyses to validating them.
The bottleneck moves. Generating the analysis is no longer the hard part; knowing you can trust it is.
[0:40] If I had to compress the whole Perspective into one sentence, it is this. The hard, rate-limiting step used to be building the pipeline. Agents have largely dissolved that. What they have not dissolved, what they actually make harder, is knowing the result is correct. The rest of the talk is about that gap: how it fails, what it costs, and what we do about it. Pause here.
The new bottleneck
Failure is silent, plausible, and consequential
Plausible
Formatted correctly, reads fluently: exactly what a reviewer expects to see.
Confident
States a wrong answer in the same tone as a right one. No flag, no uncertainty.
Consequential
The failure is a missed cancer gene or a wrong dose, not a 404. And it scales.
ILLUSTRATIVE
A healthy 32-year-old's exome is screened. The agent calls a pathogenic BRCA1 frameshift "likely benign", with a clean report, a citation, and no flag. She is never offered screening. The first sign is stage IV cancer. Nothing crashed.
A confident, plausible, wrong answer is worse than no answer. Safe uncertainty beats confident hallucination.
[1:40] Why is validation the hard part? Because of how agents fail. The output is plausible: well formatted, fluent, exactly what you expected. It is confident: a wrong answer in the same tone as a right one, no hedge, no flag. And in our domain it is consequential: not a broken web page, a missed cancer gene or a wrong drug dose. The box is labelled illustrative, deliberately: a constructed scenario, not a case I observed. A BRCA1 frameshift quietly downgraded to likely benign: clean report, real-looking citation, no flag, no screening offered. Nothing crashes. Now imagine that across ten thousand genomes overnight. The next slide is not illustrative. It actually happened.
Not hypothetical
A real silent failure, caught and fixed in public
The bug
An empty input file, no genomic data at all, was fed to a ClawBio pharmacogenomic skill.
It returned a clean "all normal" report, with recommended doses for 51 drugs. No error. No flag.
The audit
In the first weeks of release, a computational biologist stress-tested the library in the open.
The silent failure was found, reported, and disclosed publicly, not quietly patched.
The fix
Empty, malformed and content-free inputs now halt with an explicit error and a non-zero exit.
A silent degradation became a loud, diagnosable failure (re-tested 2 Jun 2026).
This is the governance layer of validation: open audit → public disclosure → a fix that fails loudly. The pattern is the point, not the skill.
[1:40] This one is real and documented in the paper. A ClawBio pharmacogenomic skill was handed an empty file, literally no genomic data. Instead of refusing, it returned a tidy, all-normal report, including dosing for fifty-one drugs. No crash, no warning. That is the silent-failure mode in the flesh. What matters is what happened next: a computational biologist stress-testing the library in the open found it and disclosed it publicly, not a quiet patch. The fix: empty, malformed and content-free inputs now halt with an explicit format error and a non-zero exit. We re-ran the perturbation on the current release in June; it fails loudly every time. The lesson is not about one skill; it is that the governance loop, open audit and a loud fix, is a first-class part of validation. Closed development would have hidden this. Open development caught it.
ClawBio
An open, agent-native skill library for bioinformatics · open-source · local-first · reproducible
90
open skills
48
contributors
218
forks
~1k
GitHub stars
The adoption signal that matters: within weeks, wet-lab biologists with little coding experience were contributing tested, working skills, using the LLM as the programming intermediary.
A skill is a contract
A plain-text SKILL.md plus code: what it does, what it needs, the steps the agent must follow.
The connecting layer
Links agents to genomic databases, clinical knowledge and validation workflows.
Open and auditable
Anyone can write, audit and reuse skills. The aim is a trust layer for agentic genomics.
github.com/ClawBio/ClawBio · models, including Genomic Intelligence's, plug in as skills; what is auditable is the SKILL.md contract and the execution trace.
[1:30] So what is ClawBio? An open, agent-native skill library for bioinformatics: open-source, local-first, reproducible. I will show numbers but be honest about which mean anything. Stars and forks are attention, not use; they are in grey for a reason. The signal I care about is the middle line: within weeks of release, wet-lab biologists with little coding experience were contributing tested, working skills, using the model as their programming intermediary. Domain experts encoding knowledge directly, which is the whole point. The mechanism is the bottom three: a skill is a contract, a plain-text SKILL.md plus code stating what it does, needs, and the steps to follow; it is the connecting layer; it is auditable. On openness, and this matters before Benjamin speaks: GI's models plug in as skills inside this library. What is open and auditable is the contract and the execution trace; the trust story lives there, around whatever model sits in the middle.
The evidence
Can a plain-text skill reach reliable execution?
Pharmacogenomics, the one corner with clean ground truth (CPIC). 44,550 scored evaluations across frontier models, three conditions.
80.6%
Free prompt no specification
→
95.5%
Skill reasoning guideline loaded
→
100%
Skill execution deterministic, by construction
100% is not the model getting smarter; it is the model removed from the answer. Correctness is constrained by architecture, not by a better prompt.
[1:50] Does a plain-text skill buy you anything? Here is the evidence, and I want to be precise because this number gets misread. We took pharmacogenomics, deliberately, because it is the one corner of genomics with an authoritative ground truth, the CPIC guidelines, and ran 44,550 scored evaluations across frontier models in three conditions. Free prompt: about 81%. Guideline as reasoning context: 95.5%. Skill executes the guideline deterministically: 100%. The honest reading of that 100%: not the model becoming cleverer, the model taken out of the answer. The deterministic skill applies CPIC logic the same way every time; correctness is constrained by architecture, not by asking nicely. And note the scope: this is PGx, where truth is tabulated. Alignment and variant calling have no CPIC, which is exactly why the framework I show in a moment matters.
The counterintuitive result
The right guideline made the model more dangerous
Trust is architectural: it comes from deterministic, auditable, model-invariant execution, not from a better prompt.
[1:20] The result that should give everyone pause, found only because we scored at scale. Give the model the correct guideline as context and average accuracy goes up; the headline improves, most cases get better. But underneath the average, a minority of previously safe answers flipped to confident and wrong. Adding the right information created a new failure mode the average concealed. This is why I do not trust prompt-level fixes for consequential work: a better prompt can raise the mean and quietly introduce new, fluent, hard-to-catch errors. Trust has to be architectural: deterministic, auditable, the same regardless of model. That is the bridge to the most important slide, because this gets worse the moment you leave curated European data.
The headline
On real genomes, accuracy falls by ancestry
Curated ~96% does not transfer to real diplotypes from 7,000+ individuals; error grows with distance from the European reference. Executing the skill removes the gradient. Validation is an equity problem.
[2:00] The slide I would build the whole talk around. That curated 96% is measured on clean, curated cases. Run the same skill on real diplotypes from over seven thousand actual people and it collapses, and it collapses by ancestry. European, 72%. Latin American, from the Peruvian Genome Project, 51%. East African, from the Uganda Genome Resource, 40%. Accuracy falls with distance from the European reference the tools were built on. This is not an ethics footnote; it is a correctness result. An agent left to its defaults reaches for the most abundant European resources and silently inherits this gradient, at scale. The green line: when the skill executes deterministically, every ancestry returns to roughly 100%. The fix for the equity gap and the fix for the trust gap are the same fix. Equity has to be engineered, not declared.
So what do we do
Validation proportional to consequence
Research-grade
Hypothesis exploration
Unit tests; adversarial inputs (empty, malformed, edge cases); researcher reviews every output.
Benchmarked
Publishable analyses
Validated on public reference sets (GIAB, curated atlases); metrics with CIs; documented failure modes.
Today, every surveyed system sits at research-grade. None has published the external evidence the clinical tier demands; that gap is itself the finding.
[1:40] So what do we do? Not abandon agents: calibrate scrutiny to consequence. Three tiers. Research-grade: exploration, where you need unit tests, adversarial inputs (the empty file from slide seven) and a human reading every output. Benchmarked: publishable work, validation on public reference sets like Genome in a Bottle, metrics with confidence intervals, documented failure modes. Clinical-grade: patient care, external multi-site validation, signed reproducibility bundles, audit trails, regulatory alignment, CLIA and CAP. The uncomfortable part, applying to ClawBio too: every system we surveyed, ours included, currently sits at research-grade. None has published the external multi-site evidence the clinical tier requires. That is the finding. The field generates analyses far faster than the evidence to trust them in consequential settings. The job is to close that distance, tier by tier.
What to remember
Three things to take away
1
The bottleneck has moved
Agents produce analyses faster than we can check them. Your scarce skill is now judgement, not code.
2
Trust is architectural
It comes from deterministic, auditable, model-invariant execution, not from a better prompt or a bigger model.
3
Equity is engineered, not declared
The accuracy gap across ancestries is a correctness gap. The fix is the same as the fix for trust.
Domain expertise is the one thing that cannot be automated; it is the irreducible human contribution to an increasingly automated science.
[1:00] If you remember three things, these. One: the bottleneck has moved; agents produce faster than we can check, so your scarce skill is now judgement, not code. Two: trust is architectural; deterministic, auditable, model-invariant execution, not a cleverer prompt or a bigger model. Three: equity is engineered, not declared; the accuracy gap across ancestries is a correctness gap, and the fix is the same fix as for trust. Underneath all three sits the one thing that does not automate: domain expertise. That is the irreducible human contribution. With that, over to the live work.
Over to Genomic Intelligence
From the framing to the live work
Next, with Benjamin & the GI team
What the Genomic Intelligence models are, and where they fit.
Live scenarios: GI skills running inside ClawBio on real bio problems.
Follow along in Codex; prompts and links go in the chat.
Try it yourself, now
Ask a real, openly published genome questions, live: every answer executed by a ClawBio skill.
conversational.clawbio.ai
Star the repo: github.com/ClawBio/ClawBio
The point of the demos is not "the agent can run it"; it is "you can trust what it ran".
[0:50] That is my framing. Over to the live work. Benjamin and the GI team show you what the Genomic Intelligence models are and where they fit, then run live scenarios: GI skills inside ClawBio on real, openly published genomes. Follow along in Codex; we will drop prompts and links in the chat. You do not have to watch passively: go to conversational.clawbio.ai right now and ask a real genome a question; every answer is executed by a ClawBio skill, not improvised by a chatbot. Keep one test in your head: the demos are not trying to prove the agent can run it. They show you can trust what it ran. Benjamin, over to you.
Build with us
Take it further
Out now
Build an Agentic Genomics System (From Scratch)
Paperback & Kindle · 328 pages
Build it in your browser on a real, openly published genome: your first runnable skill in minutes, then the agents and guardrails that keep them honest.
Join the community
WhatsApp group
scan with your camera
Hackathons & workshops: luma.com/ClawBio
Open call: ship your own use case on the platform in the next two weeks. Best submissions win.
Try it live: conversational.clawbio.ai · Build with us: github.com/ClawBio/ClawBio
[0:40] Two ways to take this further while the demos run. The book, Build an Agentic Genomics System From Scratch, is hands-on; you build it in your browser on a real published genome, your first runnable skill in minutes and then the validation and guardrails that keep agents honest. Scan the left QR. Join the community on the right: WhatsApp for the conversation, Luma for hackathons and workshops. The open call stands: ship a use case on the platform in the next fortnight, and the best submissions win. Now, let's watch it run.
