# Robin Disease Discovery

> Multi-agent automated scientific discovery for diseases — given a disease name, Robin generates and ranks experimental assays, proposes therapeutic candidates, and (optionally) analyzes wet-lab data. Open-source, Apache-2.0. Use when the user wants an end-to-end "I have a disease, give me hypotheses to test" workflow rather than a single literature lookup.

- Skill: `qhjqhj00/robin-disease-discovery` (Agent Skill, multi-file: 10 files)
- Install (CLI): `npx skillmds add qhjqhj00/robin-disease-discovery`
- Raw SKILL.md: https://api.skillmd.com/api/skills/qhjqhj00/robin-disease-discovery/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Product & Planning
- Author: qhjqhj00 (https://skillmd.com/u/qhjqhj00)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/qhjqhj00/robin-disease-discovery

---


# Robin — Multi-Agent Disease Discovery System

Robin is FutureHouse's open-source multi-agent system for automating early-stage scientific discovery. Given just a disease name, Robin orchestrates literature search, hypothesis generation, ranking, and (optionally) experimental data analysis to produce a ranked list of:

1. **Experimental assays** to test pathogenic mechanisms
2. **Therapeutic candidates** likely to work against the top-ranked assay
3. (Optional) Re-ranked candidates after Finch analyzes any provided wet-lab data

Reported in [arXiv:2505.13400](https://arxiv.org/abs/2505.13400) and demonstrated end-to-end on 10 diseases (Glaucoma, Celiac, Friedreich's Ataxia, NASH, etc.) — example outputs ship in the repo.

## Prerequisites

- Python ≥ 3.12
- An LLM API key (defaults to `o4-mini`, set `OPENAI_API_KEY`; any LiteLLM-compatible provider works)
- An `EDISON_API_KEY` for the literature/precedent components (Crow / Falcon / Owl) — get one at <https://platform.edisonscientific.com/profile>
- Wet-lab data analysis step additionally needs Finch access on the platform (skippable)

## Install

```bash
git clone https://github.com/Future-House/robin.git
cd robin
uv venv .venv && source .venv/bin/activate
uv pip install -e '.[dev]'

cp .env.example .env
# Edit .env to add EDISON_API_KEY and OPENAI_API_KEY (no quotes)
```

Docker option (recommended for clean environments):

```bash
docker build -t robin .
docker run -p 8888:8888 --env-file .env robin
# Open the http://127.0.0.1:8888/lab/tree/robin_demo.ipynb URL Jupyter prints
```

## Run

Either open `robin_demo.ipynb` in Jupyter, or use programmatically:

```python
from robin import RobinConfiguration, experimental_assay, therapeutic_candidates

config = RobinConfiguration(
    disease_name="Idiopathic Pulmonary Fibrosis",
    # Optional explicit overrides (otherwise read from env):
    # edison_api_key="...",
    # llm_name="claude-opus-4-5",
    num_queries=5,         # literature queries per stage
    num_assays=10,         # candidate assays to generate
    num_candidates=20,     # therapeutic candidates to propose
)

# Stage 1 — generate + rank experimental assays
assay_results = experimental_assay(config)

# Stage 2 — propose + rank therapeutic candidates against the top assay
candidate_results = therapeutic_candidates(config)

# (Optional) Stage 3 — analyze wet-lab data, re-rank
# from robin import data_analysis
# updated = data_analysis(config, dataset_path="my_screen.csv")
```

## What you get back

Robin writes everything to `robin_output/<DISEASE>_<TIMESTAMP>/`:

```
robin_output/IPF_2026-05-08_14-30/
├── experimental_assay_summary.txt
├── experimental_assay_detailed_hypotheses/    # one .txt per assay, full reasoning
├── experimental_assay_literature_reviews/      # supporting lit reviews
├── experimental_assay_ranking_results.csv      # pairwise comparison results
├── therapeutic_candidates_summary.txt
├── therapeutic_candidate_detailed_hypotheses/
├── therapeutic_candidate_literature_reviews/
├── ranked_therapeutic_candidates.csv           # final ranked list with scores
└── (if data_analysis run)
    └── data_analysis/                         # Finch outputs, consensus_results.csv
```

## Demo recipe (no wet-lab data)

```python
from robin import RobinConfiguration, experimental_assay, therapeutic_candidates

config = RobinConfiguration(disease_name="Friedreich's Ataxia")
experimental_assay(config)        # ~10–20 min, $5–20 in LLM + Edison credits
therapeutic_candidates(config)    # ~20–40 min
# Open ranked_therapeutic_candidates.csv to see results
```

The repo also ships `examples/<disease>/` — pre-generated outputs for 10 diseases. **For a no-credit demo, just open these example folders and walk through the structure.**

## When to use Robin vs alternatives

| Need | Use |
|---|---|
| End-to-end disease → assays + candidates | **Robin** (this skill) |
| Single literature question | Crow |
| Deep review on a topic | Falcon |
| Analyze a dataset you already have | Finch |
| Just chemistry / molecule design | Phoenix |

## Cost / latency expectations

- A full Robin run takes **30 min – 2 hours** for typical diseases.
- LLM costs typically **$10–$50 per disease** with `o4-mini` defaults; more with larger models.
- Edison credits are consumed by every literature search — budget accordingly.

## Caveats

- Robin produces *hypotheses to test*, not validated science. Treat its ranked candidate list as a starting point for wet-lab work, not as evidence.
- The data_analysis stage requires Edison platform access (Finch). Without it, stages 1–2 still work fully.
- Default LLM is `o4-mini` — change `llm_name` in `RobinConfiguration` for higher-quality runs.
- Examples in `examples/` show typical output structure including occasional errors — useful for debugging your own run.