Ahuja Lab · IIIT Delhi · Targeted protein degradation

An evidence-grounded autonomous research system for targeted protein degradation

PROTACXtend couples scientific literature and biochemical databases with component-aware molecular design and controlled chemical-space search. It then models ternary-complex physics and mechanistic degradation with DC50/Dmax prediction under cell-context reasoning — every candidate decision carries explicit provenance, uncertainty and applicability-domain checks.

Pipeline walkthrough Read the docs
PROTACXtend research-system overview — evidence retrieval, component-aware molecular design, ternary-complex reasoning and degradation prediction
01 KNOW Literature & database evidence before inference 02 REASON Evidence into explicit design decisions 03 DESIGN Constrained chemical & structural search 04 DISCOVER Converging evidence into prioritization

A research system, not a demo — every stage runs with its own tools, models and an explicit evidence type, and walkthrough values are illustrative unless marked otherwise.

Quick start
git clone https://github.com/the-ahuja-lab/PROTACXtend.git Run from source — PyPI publishing on the roadmap.
0core scientific nodes
+8search & feedback extensions
0live retrieval APIs
0committed ML artifacts
0chemistry-engine methods

ABOUT · 01

PROTAC design is a coupled biological, structural and chemical optimization problem

No single molecular descriptor predicts degrader success. PROTACXtend makes every contributing layer independently inspectable.

A PROTAC cannot be optimized from molecular structure alone. Potency depends jointly on warhead engagement, E3 recruitment, linker geometry, ternary-complex topology, cooperativity, accessible ubiquitination geometry, intracellular concentration, cellular ubiquitin–proteasome context and developability. These factors interact nonlinearly and can generate counterintuitive behaviours including the hook effect.

PROTACXtend decomposes this coupled problem into independently inspectable evidence and modeling layers. Research agents retrieve and verify evidence; chemistry modules construct and validate candidates; structure-aware modules evaluate ternary and ubiquitination feasibility; degradation models estimate DC50 and Dmax; transcriptomic context models condition predictions on cellular state; and ranking modules combine potency, uncertainty, novelty, ADMET and synthetic feasibility without hiding missing evidence.

PROTACXtend system map: evidence retrieval, controlled search, molecular design, mechanistic modeling and degradation prediction
CALCULATED RETRIEVED LEARNED PREDICTION System map — evidence retrieval and component-aware search feed mechanistic modeling (ternary, ubiquitination, hook equilibrium) and degradation/cell-context prediction. Illustrative overview; see Validation matrix for per-layer status.

SCIENTIFIC LOOP · 02

One scientific loop from evidence to degrader prioritization

The platform is organised around the research workflow a degradation biologist actually follows — not around "agents". Each stage names its sources, models and statuses.

01

KNOW

Evidence before inference

  • Europe PMC · PubMed · OpenAlex retrieval
  • Crossref citation graph
  • SearXNG web search (self-hosted, configurable)
  • Robots-aware full-text retrieval / crawling
  • DOI & title verification
  • Claim-level evidence grading
RETRIEVEDresearch/sources.py
02

REASON

Evidence into explicit design decisions

  • Target resolution (UniProt / ChEMBL)
  • Binder & warhead evidence ranking
  • E3 ligase recruitment selection
  • Exit-vector reasoning
  • Applicability domain & uncertainty/OOD checks
  • Scientific critic + stop / revise / insufficient-evidence gates
CALCULATEDagents/graph.py · nodes 1–23 core
03

DESIGN

Constrained chemical & structural search

  • Component-aware warhead · linker · recruiter representation
  • Curated + rule-based + generative linker design (73-method engine)
  • Stereochemistry-aware assembly & RDKit validation
  • Retrosynthetic feasibility & synthetic filters
  • ADMET profiling (hERG · AMES · BBB · Lipinski/Veber)
  • Ternary-complex modeling (P4ward, SE(3) feasibility)
CALCULATEDprotac_toolbox.py
04

DISCOVER

Prioritize by converging independent evidence

  • Hook-effect equilibrium · lysine ubiquitination feasibility · cooperativity feasibility
  • Independent predictors: Module 4, Module 5, TACK, SynGlue
  • Model disagreement & uncertainty/OOD surfacing
  • Pareto ranking across potency · novelty · ADMET · synthetic feasibility
  • Experimentally actionable candidate dossiers
  • Active learning: CLI surface exists; BO loop planned (Module 7)
LEARNED PREDICTIONmodules/* · data/tack · data/synglue

MECHANISTIC LAYERS · 03

From ternary formation to cellular degradation

PROTACXtend models distinct mechanistic determinants instead of collapsing degrader efficacy into a single score.

Ternary-complex ensemble→ E2–lysine geometry→ Ubiquitination feasibility→ Cooperativity feasibility→ Hook-effect equilibrium→ DC50 / Dmax prediction→ Cell-context conditioning→ Degradation verdict
CALCULATED · EQUILIBRIUMVALIDATED BASELINE

Hook-effect modeler

Mass-action three-body equilibrium over binary and ternary species: peak and maximum ternary occupancy, hook onset and severity, dose window — with seeded Monte-Carlo uncertainty propagation.

Limitation: equilibrium modeling, not degradation kinetics; input affinities come from experiment or upstream layers.

modules/hook_effect_modeler · 13/13 tests
STRUCTURAL SURROGATEPARTIAL

Lysine ubiquitination feasibility

Static-geometry scorer of E2 catalytic-site accessibility to POI lysines: Shrake–Rupley SASA, distance, approach angle, steric occlusion and the productive fraction of an ensemble.

Limitation: static-geometry baseline; real-PDB benchmark is pending — synthetic-fixture validated today.

modules/lysine_ubiquitination_feasibility
STRUCTURAL SURROGATEDATA-GATED

Cooperativity feasibility

A feasibility score, not a trained experimental-α predictor. Surrogate mode until a curated experimental cooperativity dataset exists; grouped-split benchmark harness (constant / ridge / RF / XGB / GP) is ready.

Limitation: experimental cooperativity (α) prediction is data-gated.

modules/cooperativity_alpha_predictor
LEARNED PREDICTIONTRAINED

Degradation & cell context

pDC50 / Dmax regression trained on a curated set of 64/32 published labels with grouped splits; a separate transcriptomic cell-context model conditions pDC50 on DepMap 24Q4 expression.

Limitation: small curated label set; transcriptomic only — proteotype coverage is not claimed; unseen-cell-line transfer is not claimed.

modules/degradation_ml · modules/cell_context_selector

MODEL PANEL · 04

Independent degradation models, one auditable evidence layer

Predictors are kept independent with their provenance shown — models are never averaged silently, and any unified integration is labelled "under evaluation".

PredictorEndpointTypeTraining-data provenanceValidation regimeStatus
Module 4 — degradation MLpDC50 · DmaxLEARNED PREDICTION64/32 curated published labelsgrouped splits: random · scaffold · unseen-target · E3 · PROTAC; 9/9 audit testsTRAINED
Module 5 — cell contextcell-context pDC50LEARNED PREDICTIONPROTAC-Degradation-DB (1913 rows) + DepMap 24Q4 transcriptomics (1512 rows)grouped A–G; leg D > leg B on unseen-PROTAC pDC50 (R² 0.605 vs 0.513); 16 testsTRAINED
TACK — DC50DC50LEARNED PREDICTIONTACK datasetcalibration parquet + meta committedTRAINED
TACK — Dmax / binaryDmax · active/inactiveLEARNED PREDICTIONTACK datasetcalibration parquet + meta committedTRAINED
SynGlue — DC50 / DmaxDC50 · DmaxLEARNED PREDICTIONGROVER / multitask-transformer encodingsRF regressors + transformer committedTRAINED
Unified degradation engineensemble verdictHEURISTIC— (integration layer)model-disagreement & uncertainty-aware integration in evaluationUNDER EVALUATION

Each predictor ships with its artifact path (e.g. modules/degradation_ml/models/pdc50_model.joblib, data/tack/tack_dc50_model.joblib, data/synglue/models/rf_dc50.joblib). Verdicts cite which model produced them and with what applicability-domain state.

ARCHITECTURE · 05

A governed scientific graph with explicit evidence and model gates

23-node core scientific workflow + 8 controlled-search and feedback extensions = 31 documented agent nodes. The orchestration graph executes nodes in sequence and stops only at terminal evidence or error gates.

23core scientific workflow nodes
supervisor → planning → discovery → assembly → evaluation → ranking
+
8controlled-search & feedback extensions
expensive-modeling selection → ternary/cooperativity/hook gates → final ranking → learning → report → memory
=
31documented agent nodes
production path: agents/graph.py
CORE
Governance & planning
nodes 1–4 · core
parse_user_requestcreate_design_plancontrol_np_hard_searchsafety_precheck
CORE
Discovery — evidence grounding
nodes 5–9 · core
resolve_targetretrieve_target_bindersselect_warheadsselect_e3_ligandsdetect_exit_vectors
CORE
Component-aware assembly
nodes 10–14 · core
generate_linkersconstruct_protacsexpand_stereoisomersvalidate_protacsscore_cell_context
CORE
Evaluation & reflection
nodes 15–23 · core
predict_admetcheck_noveltyassess_applicability_domaincheap_filter_candidatespredict_degradationinitial_rankingdiversity_clusteringreflection_reviewevolution_refinement
EXT
Controlled-search & feedback extensions
nodes 24–31 · extensions
select_expensive_modeling_finalistsoptional_ternary_feasibilitypredict_cooperativitypredict_hook_effectfinal_rankingactive_learning_updategenerate_reportupdate_memory

The scientific contract

Each executed scientific step records its input, output, evidence source, tool/model version, confidence, applicability-domain status, warning state and limitation. No agent silently mutates another node's conclusions.

  • Shared typed workflow state; one falsifiable task per node; evidence written back to state.
  • Retry and escalation gates pause the run when evidence is missing — never fabricate.
  • Deterministic state-machine path and an optional LangGraph path share one node registry (agents/graph.py).
  • Dossiers and decision traces are inspectable via protacxtend contract.
protacxtend · research shell

$ protacxtend contract --target BRD4 --e3 CRBN

→ KNOW-REASON-DESIGN-DISCOVER dossier: sources cited, gates passed

$ protacxtend structure --smiles "<PROTAC>" --pose model_0

→ lysine ubiquitination feasibility + cooperativity feasibility (surrogate)

$ protacxtend dose --smiles "<PROTAC>"

→ ternary dose-response · hook onset & severity · MC uncertainty

$ protacxtend context --smiles "<PROTAC>" --cell-line HeLa

→ cell-context-aware degradation verdict (Module 5), with model tag

WORKFLOWS · 06

Reproducible workflows from research question to candidate dossier

One CLI, real subcommands, structured JSON/CSV output — each workflow names the models and evidence types it touches.

designcore pipeline

Deterministic end-to-end candidate generation: target resolution → assembly → validation → ADMET/novelty → ranking → report.

protacxtend design \
  --target BRD4 --e3 CRBN \
  --num-candidates 16
structurestructural surrogate

Pose-backed lysine ubiquitination geometry scoring and cooperativity feasibility for one candidate.

protacxtend structure \
  --smiles "<PROTAC>" \
  --target-pdb 3U5L
doseequilibrium

Ternary dose-response simulation: hook onset, severity, occupancy window — equilibrium, with MC uncertainty.

protacxtend dose \
  --smiles "<PROTAC>"
contextcell context

Cell-context-aware degradation prediction (Module 5, transcriptomic) — model and applicability domain reported.

protacxtend context \
  --smiles "<PROTAC>" \
  --cell-line HeLa
validatechemistry gate

RDKit validation and scoring of a single PROTAC SMILES: sanitization, exit vectors, ADMET profile.

protacxtend validate \
  --smiles "O=C1NC(=O)..."
ask · learn · apiresearch surface

Search databases & literature (ask), recommend next experiments (learn, partial), or serve the FastAPI backend (api).

protacxtend ask "HMGB2 E3 ligases"
protacxtend api --port 8001

BROWSER WALKTHROUGH · 07

Interactive pipeline walkthrough

Explore the shape of a PROTACXtend run — including retrosynthesis and mechanistic module stages. This browser-only walkthrough uses precomputed illustrative values; it does not execute the scientific backend.

ILLUSTRATIVE DEMO — NOT A LIVE SCIENTIFIC PREDICTION Run the CLI or API (protacxtend design, protacxtend api) for model-backed results.

ILLUSTRATIVE trace. Stages shown: KNOW retrieval · REASON · linker design · retrosynthesis · assembly · ADMET · ternary · ubiquitination · cooperativity · hook effect · degradation (M4) · cell context (M5) · Pareto ranking.

Node-by-node trace (illustrative)STANDBY
WalkthroughReady Choose target + E3 and press “Run walkthrough”. STANDBY

Illustrative Pareto-ranked candidates

awaiting run
RankPROTAC candidateM4 pDC50Ternary feas.Retro. feas.ADMETStatus
Run the walkthrough to see an illustrative output shape.

SCIENTIFIC VALIDATION · 08

Know exactly what is measured, modeled, inferred or still missing

Source of truth: config/scientific_status.yaml. Statuses are per capability, not page-level. Green is not used alone — every claim carries a caveat column.

VALIDATED BASELINE TRAINED PARTIAL STRUCTURAL SURROGATE DATA-GATED UNDER EVALUATION PLANNED
CapabilityImplementedEvidence typeData sourceValidationCurrent limitationPublic claim
Deep-research retrieval✓RETRIEVEDEurope PMC · PubMed · OpenAlex · Crossref · SearXNGlive-API smoke + testsSearXNG needs self-hosted instanceYES
Hook-effect modeler✓CALCULATEDvalidated mass-action equations13/13 tests, QA 2026-09-02equilibrium only — no kineticsYES
Lysine ubiquitination feasibility✓STRUCTURAL SURROGATEpose geometry (SASA, angles)synthetic fixturesreal-PDB benchmark pendingPARTIAL
Cooperativity✓ (surrogate)STRUCTURAL SURROGATEfeasibility scoringharness ready (ridge/RF/XGB/GP)experimental α dataset absent — prediction data-gatedDATA-GATED
Degradation ML (M4)✓LEARNED PREDICTION64/32 curated published labelsgrouped splits; audit 9/9small label setYES
Cell-context degradation (M5)✓LEARNED PREDICTIONPROTAC-Degradation-DB + DepMap 24Q4 RNAgrouped A–G; 16 teststranscriptomic only; unseen-line transfer & proteotype not claimedYES
Unified degradation engine±HEURISTICintegration layerdisagreement/uncertainty checksnot production — under evaluationNO
Novel E3 opportunity✗NOT AVAILABLE——Module 6 plannedNO
Active learning±HEURISTICCLI surface only—BO + feedback module not built (Module 7)NO

Evidence-type badges used across this site

MEASUREDRETRIEVED CALCULATEDLEARNED PREDICTION STRUCTURAL SURROGATEHEURISTIC ILLUSTRATIVENOT AVAILABLE

DOCUMENTATION · 09

Reproduce, inspect and extend every layer

Technical how-to for what ships in the repository: databases, live APIs, tools, models and spreadsheet assets — with source paths for each.

Getting started

Python 3.10+ with conda is recommended for RDKit / PyTorch isolation. Two supported install paths — both run from the repository source; PyPI publishing is on the roadmap.

Option A — git clone

git clone https://github.com/the-ahuja-lab/PROTACXtend.git
cd PROTACXtend
conda create -n protacxtend python=3.10 -y
conda activate protacxtend
pip install -r requirements.txt
pip install -e .

Option B — docker

docker build -t protacxtend https://github.com/the-ahuja-lab/PROTACXtend.git
docker run -p 8501:8501 -p 8001:8001 protacxtend

Verify the environment

protacxtend status          # runtime status
protacxtend capabilities    # terminal + scientific capabilities
protacxtend scenarios       # example runs & cost estimates

Committed model artifacts and curated data are checked by the CI security job; nothing model-sized needs re-downloading to run offline tests.

Technical assets — what you get, and how to use it

Machine-readable status source: config/scientific_status.yaml. Full module docs live beside each module under docs/{README,ARCHITECTURE,USAGE,VALIDATION,LIMITATIONS,REFERENCES}.md.

Databases & live APIs

UniProttarget resolution · protein metadata (live API)
ChEMBL · PubChembinders, warheads, bioactivity evidence (live API)
BindingDBaffinity evidence (live API / TSV mode)
Europe PMC · PubMed · OpenAlex · Crossrefresearch retrieval + citation graph (research/sources.py)

Tools (agents call these)

  • Chemistry engine — tools/protac_toolbox.py: 73 methods (parse/validate, exit vectors, assembly, enumeration).
  • Retrosynthesis — tools/retrosynthesis*.py: engines + filter; heavy backends optional/guarded.
  • ADMET — hERG · AMES · BBB · Lipinski/Veber radar.
  • Ternary / docking — P4ward SE(3) feasibility; external docking adapters guarded.
  • Module tools — hook-effect, lysine-ubiquitination, cooperativity, degradation, cell-context (JSON in/out, graph-safe).

Spreadsheet assets (xlsx/csv) shipped in-repo

  • data/benchmark/PROTAC-DB_3.0_protacs.xlsx — benchmark + training provenance.
  • Agent_Toolkit.xlsx & data/toolkit/Agent_Toolkit_EXPANDED.xlsx — agent/module capability registry (load with openpyxl).
  • TOOL_AUDIT.xlsx — tool audit log.
  • data/protac_repos/protac_repo_registry.xlsx — upstream PROTAC repo registry.
  • protacxtend/modules/cell_context_selector/data/context_joined.csv — Module 5 features (DepMap 24Q4).
# read an xlsx asset
from openpyxl import load_workbook
wb = load_workbook("Agent_Toolkit.xlsx")

Modules & models — status at a glance

Built sequentially, each module gated by tests, a demo output, documented limitations and agent integration. Tracker: protacxtend/modules/PROTACXTEND_MODULE_BUILD.md; status YAML: config/scientific_status.yaml.

M1Hook Effect Modeler — three-body equilibrium, hook onset/severity · VALIDATED BASELINE
M2Lysine Ubiquitination Feasibility — static-geometry scorer · PARTIAL (real-PDB benchmark pending)
M3Cooperativity — feasibility/surrogate mode · DATA-GATED
M4Degradation ML — pDC50/Dmax, curated 64/32 labels · TRAINED
M5Cell-context selector — transcriptomic (DepMap 24Q4) · TRAINED (proteotype not claimed)
M6Novel E3 opportunity engine · PLANNED
M7Active learning / experiment selection · PLANNED (CLI surface exists)

Model artifacts (committed)

protacxtend/modules/degradation_ml/models/pdc50_model.joblib
protacxtend/modules/cell_context_selector/models/cell_context_model.joblib
data/tack/tack_{dc50,dmax,bin}_model.joblib        (+ calibration parquet)
data/synglue/models/rf_{dc50,dmax}.joblib
data/synglue/models/multitask_transformer.pt · data/synglue/models/grover_fixed.pt
outputs/benchmark/chemprop_multitarget/model_0/best.pt

Models are invoked through tagged tools; verdicts report which model(s) produced them. The unified engine is under evaluation and is never presented as production.

Workflows & CLI

Every workflow writes structured output and cites its evidence/model layer.

End-to-end design

protacxtend design --target "BRD4" --e3 "CRBN" \
  --num-candidates 16 --output ./results/brd4_run.json

Core 23-node path: resolution → binders/warheads/E3 → exit vectors → linkers → construction → stereoisomers → validation → ADMET · novelty · applicability domain → degradation ML → ranking; controlled-search extensions follow when their gates open.

Mechanistic & context layers

protacxtend structure --smiles "<PROTAC>" --target-pdb 3U5L --e3-pdb 4CIW
protacxtend dose      --smiles "<PROTAC>"              # hook equilibrium
protacxtend context   --smiles "<PROTAC>" --cell-line "HeLa"
protacxtend validate  --smiles "<PROTAC>"

Research surface

protacxtend ask "HMGB2 degradation E3 options"   # search tools/databases/literature
protacxtend contract --target BRD4 --e3 CRBN     # KNOW-REASON-DESIGN-DISCOVER dossier
protacxtend learn                                 # recommend next experiments (partial)

Serving

protacxtend api      # FastAPI backend   (default :8001)
protacxtend ui       # Streamlit frontend (default :8501)

API & data access

Python workflow entrypoint

from protacxtend.agents.graph import run_syn_glue_workflow

state = run_syn_glue_workflow(
    request="Design 10 CRBN PROTAC candidates for HMGB2 with low hERG risk",
    config={"persistent": True, "max_iterations": 3})
dossier = state.get("report_markdown", "")

Chemistry engine

from protacxtend.tools.protac_toolbox import PROTACMasterToolbox
tb = PROTACMasterToolbox()
vectors   = tb.detect_exit_vectors(warhead_smiles="...")
protac_sm = tb.assemble_protac(warhead_smiles="...", linker_smiles="...", e3_smiles="...")

REST endpoints (FastAPI)

POST /designstructured end-to-end design run
POST /modeagentic mode routing
GET /healthbackend liveness
curl -X POST http://localhost:8001/design \
  -H "Content-Type: application/json" \
  -d '{"request":"Design 20 CRBN PROTAC candidates for BRD4","num_candidates":20}'

GitHub & collaborators

Repository: github.com/the-ahuja-lab/PROTACXtend — canonical Ahuja Lab home (full code + Pages)
Live site: the-ahuja-lab.github.io/PROTACXtend
Development mirror: github.com/SaveenaSolanki/PROTACXtend
Lead developer: @SaveenaSolanki · Lab: @the-ahuja-lab (IIIT Delhi)

Continuous testing on GitHub

Every push runs CI: compile + asset-free smoke, fast offline units, the full offline suite (including the agentic E2E benchmark), plus gitleaks full-history scan, ruff and committed-artifact checks.

Repository hygiene & contribution

  • Status changes start in config/scientific_status.yaml and the module tracker — not in website copy.
  • PRs run the full CI matrix; scientific-claim PRs must include the evidence and validation section.
  • Spreadsheet/registry updates go through the xlsx assets listed under Technical assets.