virtual biotech

Virtual Biotech — a coordinated team of AI agents that mirrors the structure of human therapeutic research organizations to support end-to-end computational discovery.

Comment

Inspiration

Ninety percent of drug programs fail — and most fail for a single reason: lack of efficacy. The therapeutic target hypothesis was wrong, the biology never held up, and a single failed Phase 3 can burn over a billion dollars. Choosing the right target is the most expensive guess in biotech.

What struck us is that this decision is made by an organization, not a model. A real biotech runs target selection across specialized divisions — genetics, expression, clinical, safety — with a CSO coordinating and a review board that can send work back. We asked: what if you could mirror that whole structure in software?

So we built the Virtual Biotech — a coordinated team of AI agents that mirrors the structure of human therapeutic research organizations to support end-to-end computational discovery. It's a real, running multi-agent system that does target selection end to end.

What it does

A CSO orchestrator decomposes a target question into sub-tasks and routes them; it runs no analysis itself. Four scientist divisions each call real bioinformatics tools over live public databases — Open Targets, CELLxGENE, TCGA, DepMap, openFDA, ClinicalTrials.gov — and write cited edges into a knowledge graph, so nothing in the verdict is ungrounded. You can plug in your own experimental data through an MCP server (a CRISPR screen, an in-house single-cell run), and the loop projects it into cited facts that reason alongside PrimeKG — 78,000 targets, 39,000 diseases, millions of relationships.

A reviewer panel then audits the evidence and can force the org back to do more work. At every review pass a human can join the panel — approve, override, or steer the next experiment — so the org runs fully autonomous or with a scientist in the loop on the same machinery.

The part that makes a scientist trust it: the final GO / NO-GO is not written by an LLM. It's derived deductively by the Prometheux reasoning engine, with a replayable chain behind every conclusion.

How we built it

  • Agents & reasoning. We used Gemini both to write the codebase and to power the agents' reasoning across the CSO and scientist divisions.
  • Evidence as a graph. Every claim becomes a cited edge in a knowledge graph layered on PrimeKG, so the verdict is a function of grounded facts, not free-text.
  • Deductive verdict. Prometheux's Vadalog engine derives the GO/NO-GO. It also acts as a non-silenceable reviewer: a provably-missing evidence axis becomes a deductive fact that forces the org to re-work.
  • Live literature. Tavily powers the real-time literature search the scientists call.
  • Observability. Langfuse mirrors the entire loop as a hosted, replayable trace, so a run reproduces bit-for-bit.

The core insight is that the loop is iterative: each pass asks a sharper question than the last. If pass one finds B7-H3 expression looks stromal, pass two narrows to "is it on the malignant cells, or just fibroblasts?" Formally, each iteration $t$ refines the hypothesis $h_t$ by interrogating its weakest evidence axis:

$$ h_{t+1} = \mathcal{R}\big(h_t,\; \arg\min_{a \in A} \, \text{support}(a \mid h_t)\big) $$

where $A$ is the set of evidence axes and $\mathcal{R}$ is the re-route operator that commissions new analysis on the least-supported axis. The hypothesis gets progressively refined until the panel and the deductive engine converge.

Challenges we ran into

  • Keeping verdicts ungrounded-free. It's easy to let an LLM "summarize" evidence into a conclusion. Forcing every verdict through a deductive engine — with a missing axis becoming a fact rather than a silent gap — was the hard, important constraint.
  • Loop convergence. Making the re-route loop sharpen the question each pass (instead of oscillating or re-asking the same thing) took real work on how the panel votes map to the next hypothesis.
  • Bring-your-own-data without polluting the graph. We never upload raw datasets; instead we project conclusions into cited fact CSVs that bind alongside PrimeKG — preserving provenance while keeping the canonical evidence base clean.
  • Graceful degradation. Every sponsor layer is optional: the workflow always falls back to an offline, reproducible path so the demo never depends on a live service.

What we learned

The trustworthy unit in scientific AI isn't a better answer — it's a replayable chain of grounded facts with an explicit place for human judgment. Structuring agents like a real organization, and reserving the final call for a deductive engine rather than a language model, is what turns "an LLM that opines on biology" into a system a scientist can actually audit.

🏆 Sponsors

This project was built at the Multiagents Hackathon ("tokens& Hacks"), hosted by Tessl AI in London on 4 Jul 2026 — "build something real with multi-agent systems."

The event is backed by Google DeepMind, ClickHouse, Gensyn, Prometheux, Tavily, Cursor, ElevenLabs, Twilio, Tessl, and Senso.

🥇 Prometheux — primary sponsor (Intelligence Prize)

Prometheux is the decision layer of this project, not a bolt-on. The GO / NO-GO verdict is derived deductively by a Prometheux Vadalog program — no LLM generates the verdict.

How it's implemented

All in prometheux_reason.py:

  1. Graph → Vadalog facts. The CSO evidence graph (kg.py) is already a Datalog fact base — every cited edge is a ground atom with confidence + provenance. graph_to_vada() compiles it into a .vada program (facts + recursive rules
    • @model / @explain annotations). Inspect it with python3 prometheux_reason.py --vada.
  2. Recursive reasoning rules. The program derives explainable conclusions — e.g. co_niche(A,B) (shared cell-type niche, recursive), strong_claim(T,Ax) (a confidence-gated ≥ 0.8 claim as a first-class rule), and differentiates(A,B,Ax) (the explain-a-rank edges showing why one target ranks over another).
  3. Two execution paths, one program.
    • Live Prometheux (_reason_prometheux, when PMTX_TOKEN is set): the hosted Vadalog engine runs the rules via the prometheux-chain SDK — a project → concept → run → fetch sequence POSTed to the JarvisPy backend (JARVISPY_URL) — and returns native @explain output: each derived fact with a human-readable rule-chain.
    • Local fallback: a small in-process semi-naive Datalog evaluator over the same facts + rules, emitting the same @model strings. No network, no token, fully reproducible — so the reasoning always runs. Both paths return the identical ReasonResult shape, so callers are engine-agnostic.
  4. Load-bearing role — the reviewer's gap-detector. derive_gaps(graph) runs a structural-gap rule set and returns gaps in the exact shape the harness reviewer panel consumes ({missing, route_to, why, lenses, explanation, forces_reroute}). A proven missing prioritization axis (no evidence(T, Ax, _) at all) is a deductive fact, not a judgement call — so Prometheux becomes a non-silenceable panel member: such a gap forces a re-route on its own. Pull this module and the panel goes blind to structural gaps.
python3 prometheux_reason.py            # local fallback
PMTX_TOKEN=... python3 prometheux_reason.py   # live hosted engine
python3 prometheux_reason.py --vada     # print the .vada program
python3 prometheux_reason.py --gaps     # the reviewer gap-detector output

🎯 We target the Prometheux Intelligence Prize (best overall project built with Prometheux).

🔍 Tavily — live literature search

Tavily powers the live literature search feeding the cited knowledge graph.

How it's implemented

In lit_synthesizer.py: the Clinical & Literature division queries the Tavily Search API (https://api.tavily.com/search) across three search angles — each a query template — then deduplicates and returns {title, url, content, score} items as cited evidence. It is API-backed and reproducible, not page scraping: every claim carries a source URL. Live mode needs TAVILY_API_KEY; --demo replays a cached, real-shaped Tavily response with no key or network. The harness (harness.py) routes a re-route to this skill when the reviewer panel needs deeper literature evidence.

🖥️ Cursor — built in Cursor

Cursor was our development environment — this entire multi-agent system was built in Cursor, from the agent harness and Vadalog reasoning layer to the frontend and tests.

✨ Gemini — LLM agent backend

Google DeepMind Gemini is one of the live LLM backends that power the scientist and reviewer agents. The harness (harness.py) runs a provider-fallback chain (Anthropic → OpenAI → Gemini → Claude CLI) so the multi-agent loop stays running across providers; Gemini drives the live agent reasoning when selected.

🧰 Tessl — host

Tessl AI hosted the hackathon and set the brief: ship something real with multi-agent systems.

Built With

Share this project:

Updates