ADC-PK
HIC-Augmented Chemprop v2 Model for ADC Pharmacokinetic Prediction
synopsis
Standard Chemprop models learn structure–property relationships from SMILES alone. For antibody–drug conjugates (ADCs), this misses a critical variable: the hydrophobic load presented by the intact conjugate, not just the payload. ADC-PK extends Chemprop v2 with experimental developability features — principally HIC retention time — to bridge the gap between linker-payload chemistry and systemic PK.
Dataset strategy follows a tiered approach: Tier 1 — a developability dataset of ~40–80 linker-payload variants covering HIC, SEC, plasma stability, solubility, enzymatic cleavage, and cell potency. Tier 2 — a PK anchor panel of ~12–15 ADCs spanning chemical diversity, providing clearance, t½, and AUC. The Tier 1 developability screen is the highest-value early ML capability; direct PK prediction follows once the anchor panel is established.
model inputs
model outputs
key design decisions
related research
tags
HIC–PK Causal Bridge
HIC retention time measures the exposed hydrophobic surface of the intact ADC under high-salt conditions — a functional property that SMILES alone cannot encode. It acts as a bridge between linker-payload chemistry and in vivo clearance, capturing the hydrophobic load that drives FcRn competition, accelerated clearance, and off-target tissue uptake. Including HIC as a model feature, rather than a secondary endpoint, is the core architectural innovation of ADC-PK.
Data Schema — Entity Relationship
The schema is designed blank-slate and follows the tiered dataset strategy. Tier 1 tables (HIC, SEC, plasma stability, solubility, enzymatic cleavage, cell potency) target the ~40–80 variant developability screen. Tier 2 (ASSAY_PK) holds the ~12–15 anchor compounds that connect developability to PK. Tables are decoupled so any assay can be ingested independently and joined at training time. The PREDICTION table stores every inference call with uncertainty bounds and ABW credits charged.
System Interaction — Training & Prediction Flows
Training flow
Prediction flow
Iterative Optimization Loop — X-DeepSARM Analog
Inspired by Yoshimori & Bajorath (AILSCI 2026): predict → explain (SHAP) → replace worst fragment → re-predict → iterate.
The ADC-PK adaptation uses Rust MCP tools (M-09 + M-10) exposed to the adc_pk_oracle LLM,
which acts as a ReAct planner. Fragment generation is constrained to a curated linker library rather than
open LSTM generation — appropriate for the narrower ADC design space.
Rust Runtime Architecture
Training (Python — unchanged)
- Chemprop v2 + PyTorch — GPU training, K-fold CV, Optuna sweep
- Output:
model.pt+config.yamlcommitted to ABW workspace - Python stays here — Chemprop's D-MPNN training loop is Python-native
Inference & Tools (Rust)
- candle loads
model.ptweights, runs forward pass — no Python at inference - polars handles all data pipeline I/O (CSV validation, feature normalisation)
- RDKit FFI for SMILES canonicalisation and 2D descriptor calculation
- M-09 (SHAP) + M-10 (fragment oracle) compiled as Rust MCP servers
- axum serves the inference API; tokio async runtime throughout
The boundary is clean: Python owns the training loop; Rust owns everything runtime — inference, data pipeline, MCP tools, and the iterative optimization loop. This eliminates Python startup overhead and memory fragmentation from repeated LLM-tool calls during multi-round optimization.
Module Specification
| ID | Module | Technology | Inputs | Outputs | Status |
|---|---|---|---|---|---|
| M-01 | Data Intake CSV/SDF ingestion with SMILES validation, unit normalisation, duplicate detection |
Rust · polars · RDKit FFI | Raw assay CSV, SDF | Validated training dataframe | prototype |
| M-02 | Featuriser SMILES → molecular graph (Chemprop D-MPNN); experimental features (HIC, DAR, SEC, etc.) normalised into xm vector — concatenated after D-MPNN aggregation, before FFN ( h_m = cat(h'_m, x_m)). Payload class one-hot included in xm. |
Rust · RDKit FFI · Chemprop v2 --features_path |
SMILES, assay values | MolGraph + xm feature vector | prototype |
| M-03 | MPNN Backbone D-MPNN message passing on molecular graph; T=3 message passing steps, hidden size h=300 (defaults). Graph readout by mean aggregation. Optional init from pretrained Chemprop checkpoint via parameter transfer. |
Chemprop v2 · PyTorch (train) · Rust candle (infer) | MolGraph | Molecular embedding h′m | design |
| M-04 | Multi-task FFN cat(h′m, xm) → 2 hidden layers (default 300) → 3 output heads (clearance, t½, AUC). Evidential regression loss for calibrated uncertainty. Calibration evaluated by ENCE (Expected Normalized Calibration Error). Dropout + early stopping as regularisation on small N. Adam optimiser with LR warmup 10−4→10−3 then decay. |
Chemprop v2 · PyTorch (train) · Rust candle (infer) | h′m + xm | μ, σ per target (3×2) + ENCE | design |
| M-05 | Training Pipeline K-fold CV stratified by payload class; hyperparameter sweep (LR, hidden size h, depth T, dropout) using Chemprop's built-in HPO (Tree-structured Parzen Estimator — no external Optuna). Calibration check via ENCE post-training. Dropout + early stopping essential for N<50. |
Chemprop CLI · Chemprop HPO (TPE) | Validated dataframe | Best checkpoint + metrics YAML | design |
| M-06 | Model Registry Versioned model artefacts in ABW workspace git; config.yaml + model.pt per version; SHA-tracked |
ABW Workspace API · git | model.pt, config.yaml | Versioned workspace path | prototype |
| M-07 | adc_pk_oracle Agent ABW LLM agent wrapping Chemprop inference; parses query, loads model, calls M-04, interprets results, flags OOD (out-of-distribution) predictions |
ABW Agent SDK · Claude · Rust MCP server | SMILES + assay query (JSON) | PK predictions + narrative + credits | prototype |
| M-08 | Active Learning Loop Model suggests next compound to synthesize based on uncertainty + expected information gain; closes the design–make–test cycle |
Rust · Chemprop uncertainty · Claude | Current model, candidate pool | Ranked synthesis recommendations | planned |
| M-09 | SHAP Attribution Atom-level SHAP values on trained Chemprop model via gradient attribution; projects feature importances back onto linker substructures; identifies fragments driving fast clearance. Upgrades LLM-reasoned key_drivers to model-derived attribution. Exposed as Rust MCP tool. |
Rust · candle (grad) · captum FFI | SMILES + model checkpoint | Per-atom SHAP map + worst fragment SMILES | planned |
| M-10 | Fragment Replacement Oracle Constrained generative step inspired by X-DeepSARM (Yoshimori & Bajorath 2026). Replaces worst fragment (by SHAP) with alternatives from a curated ADC linker fragment library. MW / LogP / TPSA filter enforced. Output candidates fed back to M-04 for PK re-prediction → iterates up to 5 rounds. Pure Rust — no generative ML; enumeration over known linker chemotypes. |
Rust · SMARTS enumeration · linker library | Core SMILES + worst fragment + property filters | Candidate linker variants + SMILES list | planned |
Economics
Phase 1 — Wet Lab Data Generation
| Item | N | Unit cost | Total |
|---|---|---|---|
| HIC analytical run (T2X-Gem compounds) | 20 | $200–400 | $4k–8k |
| SEC analytical run | 20 | $100–200 | $2k–4k |
| Plasma stability (mouse/human) | 20 | $150–300 | $3k–6k |
| In vivo mouse PK (low/mid/high HIC) | 3 | $8k–15k | $24k–45k |
| Phase 1 total | $33k–63k | ||
Compute & ABW Inference Costs
| Operation | Compute | ABW credits |
|---|---|---|
| Phase 1 model training (20 cmpds, CPU) | ~$5–20 | — |
| Hyperparameter sweep (Optuna, 50 trials) | ~$20–50 GPU-hr | — |
| Single prediction (adc_pk_oracle) | near-zero | 15–30 cr |
| Batch prediction (10 candidates) | near-zero | 50–80 cr |
| Model file write (workspace git) | — | standard gas |
| Active learning ranking (M-08) | near-zero | 30–60 cr |
Dominant cost is wet lab data, not compute. The model itself is cheap to train and run — ABW credits cover the interpretive LLM layer, not the inference. Phase 2 (auristatin) requires 5–8 additional PK data points: ~$40k–120k incremental.
Roadmap
adc_pk_oracle Phase 1 (prior-knowledge mode) on ABW; swap to Chemprop mode when Tier 2 data lands.
adc_pk_oracle ReAct agent
(per Yoshimori & Bajorath 2026 architecture). Build Rust inference server (candle)
to eliminate Python startup latency during multi-round calls. Benchmark against known
ADC linker series. Incorporate FcRn pKD and payload release kinetics as additional features.
Open Science & Collaborative Framework
ADC-PK is designed to be hybrid: proprietary T2X assay data trains the model, but the architecture, featurisation pipeline, and agent interface are built entirely on open foundations. The goal is a reproducible, extensible framework that can be contributed back to the community once T2X data is no longer competitive-sensitive. Claude-based agents handle interpretation and uncertainty communication; open models handle the molecular representation learning.
Collaborative division of labour
- Open models (Chemprop, ChemBERTa2) handle molecular representation learning — the structural pattern recognition that requires large pretraining corpora.
- Experimental assay data (HIC, PK) provides the biological reality that no open model can infer from SMILES alone.
- Claude agents handle the interpretive layer — communicating uncertainty, flagging extrapolation, translating model outputs into chemist-legible guidance.
- Rust runtime (candle, polars, axum) handles inference, data pipeline, and MCP tools — Python is confined to the training loop.
- kask provides the experimental workflow and data management interface; ABW provides the economic and versioning infrastructure.
- The T2X training data will be published (with appropriate embargo) via TDC once competitive sensitivity has passed — contributing a novel ADC PK benchmark to the open community.