# Admet Prediction

> Turn a set of structures into absorption, distribution, metabolism, excretion, and toxicity estimates with ADMET-AI, and read them as a developability verdict rather than a table of numbers. Use this skill to run batch prediction over a library, interpret each endpoint against its DrugBank-approved percentile, and flag the liabilities that stop a series — hERG blockade, CYP inhibition, poor Caco-…

- **Type:** Skill
- **Install:** `agentstack add skill-k-dense-ai-drug-discovery-agent-skills-admet-prediction`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [K-Dense-AI](https://agentstack.voostack.com/s/k-dense-ai)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [K-Dense-AI](https://github.com/K-Dense-AI)
- **Source:** https://github.com/K-Dense-AI/drug-discovery-agent-skills/tree/main/skills/admet-prediction
- **Website:** www.k-dense.ai

## Install

```sh
agentstack add skill-k-dense-ai-drug-discovery-agent-skills-admet-prediction
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# ADMET Prediction

Potency gets a compound into a programme; ADMET decides whether it survives one. ADMET-AI is a
Chemprop-RDKit graph network trained on 41 Therapeutics Data Commons datasets, tops the TDC ADMET
leaderboard, and runs thousands of molecules a minute on a CPU. This skill is about reading its
output as a developability verdict rather than a wall of numbers.

**Tool:** [ADMET-AI](https://github.com/swansonk14/admet_ai) 2.0.1, MIT, `pip install admet-ai`
(requires Python 3.11+). Weights download on first use. No GPU needed.
**Checked against:** PyPI 2.0.1, February 2026.

Read [references/running-admet-ai.md](references/running-admet-ai.md) before your first run,
[references/endpoints.md](references/endpoints.md) to know which endpoints actually stop
programmes, and
[references/interpreting-predictions.md](references/interpreting-predictions.md) before acting on
a number — **that one is judgement, not syntax.**

## The two scripts

| Script | Answers |
|---|---|
| `admet_batch.py` | How do I feed a library in without wasting the run? |
| `admet_report.py` | Which of these compounds has a liability worth acting on? |

## Rank within a series; do not trust absolute values

This is the thing to get right. A public model has systematic offsets against your assay —
different protocol, different lab, different chemistry. Within a congeneric series those offsets
are largely **shared**, so the ordering survives even where the values do not.

Use predictions to decide *which twenty of these hundred to make and assay*. Do not use them to
decide *whether this compound will pass*. A predicted hERG of 0.7 versus 0.3 within a series is a
real signal; 0.7 in absolute terms is not a measurement.

## The percentile column is the point

ADMET-AI reports every prediction against the distribution of **approved drugs in DrugBank**, in
`_drugbank_approved_percentile`. It is the most useful thing the tool adds over a bare
model and the column most often ignored.

"Predicted clearance 12" is hard to act on. "More extreme than 92% of approved drugs" prompts the
right question: drugs exist out here, but not many — what is the argument that this one works?

## Flagging a set

```bash
python skills/admet-prediction/scripts/admet_report.py report --csv predictions.csv
```

```
smiles                              liabilities  flagged                                             out_of_domain
c1ccccc1CCNC(=O)c1ccc(Cl)cc1        5            hERG|DILI|Solubility_AqSolDB|Lipophilicity|Half_Life
CCO                                 0                                                                molecular_weight=46.07 outside [150, 700]
```

Each endpoint is flagged against **its own direction** — high solubility is good, high clearance is
bad, high hERG is very bad — so a single summed "score" over the columns would be meaningless.
`admet_report.py endpoints` prints the full registry with thresholds; they are this skill's
conventions and are meant to be argued with.

Note the second row. Ethanol is flagged as **out of domain**, not clean. ADMET-AI reports no
applicability domain, so a prediction on anything unlike its training data arrives with the same
confident four decimal places as a reliable one.

**BBB penetration has no liability direction** — essential for a CNS target, a liability
everywhere else. The script leaves it unflagged rather than guessing your programme.

## Preparing input

```bash
python skills/admet-prediction/scripts/admet_batch.py prepare --smiles library.smi --out-dir admet_in
```

```
# 3 input, 2 unique (1 duplicates collapsed), 1 chunk(s)
# warning: 1 SMILES contain `.` -- a salt, mixture, or counterion.
admet_predict --smiles_path admet_in/chunk_0000.csv --save_path admet_in/chunk_0000_pred.csv --smiles_column smiles
```

Three things this prevents. **ADMET-AI needs a CSV with a header** — a bare `.smi` list silently
loses its first molecule. **Duplicates cost twice and add nothing**, since the model is
deterministic. And **a `.` in a SMILES is a salt or mixture**: the model predicts on the string as
given, so the answer describes the wrong species. Desalt with `datamol` first.

## Four ways predictions mislead

1. **Classification outputs are probabilities, not classes.** hERG at 0.55 is a coin flip. Move
   the threshold with the cost of being wrong — screen hERG at 0.3, not 0.5.
2. **Endpoints are not equally trustworthy.** Lipophilicity and solubility are well predicted;
   DILI, clearance, and Vd are barely better than a coin flip. The leaderboard's average rank
   hides that.
3. **Real liabilities are simply absent.** Time-dependent CYP inhibition, reactive metabolites,
   transporters beyond Pgp, phospholipidosis, mitochondrial toxicity — none are covered.
4. **Over-filtering early is the expensive mistake.** Most ADMET liabilities are fixable by
   medicinal chemistry; poor potency and a wrong target are not. Filtering a primary screen on
   predicted DILI discards real chemistry on the basis of noise.

## When to stop using this

If your project has more than a few hundred measured compounds for an endpoint, train a Chemprop
model on your own data — the applicability domain finally matches your chemistry, and it will beat
any public model on it. For time-dependent CYP inhibition, transporters, or reactive metabolites,
there is no model; run the assay.

## Composing with the rest of the bundle

- `medchem` → before: structural alerts and PAINS cost nothing and catch much of this first.
- `rdkit` / `datamol` → before: desalt and standardise, or you predict on the wrong species.
- `chemical-space` → before: this is a good filter stage in an ultra-large cascade.
- `pkpd-translation` → after: predicted clearance, half-life, and PPB become dose projections.
- `deepchem` / `pytdc` → instead: when you want to train on your own data rather than use a
  ready-made model.

## Reporting results honestly

Give the percentile beside the value. Name the thresholds used and say they are conventions. State
whether the molecule sits inside a drug-like property window. Never write "this compound is a hERG
blocker" from a prediction — write "predicted hERG 0.82, above the 90th percentile of approved
drugs; assay before progressing". Say what the predictions decided: they choose what to assay,
they do not replace it.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [K-Dense-AI](https://github.com/K-Dense-AI)
- **Source:** [K-Dense-AI/drug-discovery-agent-skills](https://github.com/K-Dense-AI/drug-discovery-agent-skills)
- **License:** MIT
- **Homepage:** www.k-dense.ai

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-k-dense-ai-drug-discovery-agent-skills-admet-prediction
- Seller: https://agentstack.voostack.com/s/k-dense-ai
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.
