Complexa Binder Design

Complexa Binder Design (workflow)

From one request — "design binders for <target>" — to ranked, independently validated binders. Each returned binder is a co-designed sequence + predicted binder–target complex, gated by interface confidence, by whether the binder actually contacts the target hotspots, and by apo/holo stability.

Generation uses Proteina-Complexa (co-designs binder sequence + full-atom structure together — no inverse-folding step — with reward-guided test-time search). Validation uses a different model family (Boltz2 / OpenFold3), so the headline confidence is an independent check, not the generator grading its own homework.

Upstream model + code (you provide these):

• Project page: https://research.nvidia.com/labs/genair/proteina-complexa/
• Code: https://github.com/NVIDIA-Digital-Bio/Proteina-Complexa (the complexa CLI)
• Weights (NGC): nvidia/clara/proteina_complexa
• Paper: Didi et al., Scaling Atomistic Protein Binder Design…, ICLR 2026.

First time on a host? → references/setup.md — full standalone setup with no NIM: install Proteina-Complexa + download weights, Python deps (numpy biotite pyyaml), AF2 configure-vs-bypass, optional analyze tools (foldseek/sc/dssp), the Boltz2/OF3 validation endpoint, and every env var. Then run bash scripts/check_setup.sh for a one-shot readiness checklist.

Stage 1: Resolve target + hotspots            → target.pdb + hotspots.json   (no GPU)
        ┌──────────────────────────────────────────────────────────────────────┐
        │ repeat until ≥ N validated passers (or a stop cap):                    │
Stage 2 │   Generate (complexa design) → complex .pdb + AF2-reward-gated designs │
Stage 3 │   Validate (Boltz2 default; OF3 optional) → holo+apo + ipTM/ipSAE/     │
        │     pLDDT + apo↔holo RMSD + hotspot contact → passers                  │
        └──────────────────────────────────────────────────────────────────────┘
Stage 4: Report                               → REPORT_<target>_<run>.md (GO/NO-GO)

Composed pieces (read on demand — do not inline)

If you run inside the Proteina-Complexa repo, its bundled .claude/skills (complexa-setup, complexa-target, complexa-design) can drive the generation half; this skill adds the automated Stage 1, the independent validation, GO/NO-GO, and the manifest.

Stage 1 — resolve target and hotspots (no GPU)

The user gives a target as a name, sequence, and/or structure file. Resolve exactly one design-ready structure, in priority order: (1) experimental PDB (RCSB), (2) AFDB model (UniProt → vendor/science-skills/.../fetch_structure.py), (3) user-provided file, (4) fold de novo (MSA-Search + OpenFold3/Boltz2). scripts/pipeline.py:resolve_target_spec/resolve_target automate (1)–(2) from free text.

Hotspots = the target residues the binder should contact — a compact, surface-exposed, binder-accessible epitope. Resolve in evidence order (scripts/hotspot_strategy.py, scripts/pdb_interface.py):

1. PDB co-complex interface (gold standard) — interface residues from a structure where the target contacts a protein partner.
2. UniProt functional residues — Mutagenesis + accessible Active/Binding/Site, filtered to the extracellular/accessible range (catalytic/cytoplasmic pockets are the wrong surface for a binder and are dropped).
3. Literature (Paperclip) — full-text mining when 1–2 are empty (prompts/hotspot_paperclip.md); structure-confirmed to auto-correct numbering.
4. Unconditioned ([]) only as a documented last resort.

Then enforce, deterministically:

• Structure alignment (align_hotspots_to_structure) — drop residues absent from the coordinate file; read back the real 3-letter identity (catches UniProt↔PDB numbering offsets — never assume equal indices or chain A).
• Epitope sanity (_prune_hotspots) — one compact patch: drop outliers > 30 Å from the cluster centroid, cap at 15 residues, prefer ≥ 2.
• Size budget ≤ 500 residues (_crop_target_to_epitope) — Complexa builds an O(n²) pair-feature map over the whole complex, so crop large targets to an epitope window (original numbering preserved).

Preflight (no GPU): python3 scripts/preflight_design.py <name|accession> … reports the conditioned length, re-aligned hotspots + source, compactness, the ≤500 budget, and a READY / NEEDS-ATTENTION verdict. Review before spending GPU.

Stage 2 — generate (Proteina-Complexa, open CLI)

Register the target (hotspots + binder length are target-dict-driven), then use complexa generate (NOT the full complexa design) for the lean, fast path:

python scripts/complexa_design.py run --task-name <name> --run-name <run> \
    --algorithm best-of-n --num-samples <N> --seed 0 --out <run-dir>

complexa_design.py run defaults to the generate verb. With best-of-n + the AF2 reward (AF2 params configured via setup_af2_params.sh + AF2_DIR), the search AF2-selects the best candidates during generation and writes co-designed sequence + structure PDBs to inference/ — use the sequence directly, do not MPNN-redesign it. Search algorithms: best-of-n (default) · beam-search · fk-steering · mcts. Overrides + outputs: references/complexa-cli.md.

Do NOT run the full complexa design for this workflow. Its evaluate stage re-folds every design with AF2/RF3/ESMFold (redundant — best-of-n already AF2-selected during search**)** and its analyze stage needs foldseek/sc (usually not installed). It is much slower and adds a failure mode. The lean generate → independent Boltz2 validation (Stage 3) is the intended path.

No AF2 params? use --af2-bypass (single-pass + drop the AF2 reward); selection then falls entirely to the independent Boltz2 gate (Stage 3). Low-complexity (poly-X) sequences are dropped before spending Boltz2.