Download resources/skills/esmfold2/SKILL.md from the publisher, or copy the path and open the repository. PlugMCP lists the skill and does not host the file.
Where does esmfold2 live?
The publisher keeps it at https://github.com/aipoch/open-science.
Which agents can use esmfold2?
Claude, Cursor, and Codex can read a SKILL.md you add from the publisher's repository.
>
name: esmfold2
description: >
Biohub ESMFold2 / ESMFold2-Fast all-atom co-folding (Candido et al. 2026,
github.com/Biohub/esm). Single-sequence and MSA modes; protein, DNA, RNA,
ligand (CCD/SMILES), modified residues. FoldBench Ab-Ag 50-55%, PPI 70-77%
DockQ-pass. Also covers the ESMC-{300M,600M,6B} protein language models from
the same release: masked-LM logits, hidden states, mutation scoring, contact
prediction, and the SAE interpretability head. MIT-licensed weights on
HuggingFace org biohub. Use this skill when: (1) Predicting complex
structures with single-sequence input, (2) Validating designed binders with
ESMFold2-Fast, (3) Running ESMFold2 with MSA input, (4) Getting ESMC
embeddings or per-residue mutation scores, (5) Choosing kernel backend and
sampling-step settings for paper-faithful throughput.
The bundled esmfold2_gpu Modal env (remote-compute-modal skill) is the
canonical, version-pinned recipe.
Gotchas:
Default kernel backend is None (reference PyTorch, ~12x slower than paper). Call model.set_kernel_backend('fused') after from_pretrained(). See section below.
Match torch CUDA build to your driver; the pin <2.8 targets CUDA 12.2.
Weights via Xet bridge ~300 MB/s: ESMFold2 1.36 GB, ESMFold2-Fast 0.76 GB. Set HF_HOME=/work/hf_cache.
Usage — local model
from esm.models.esmfold2 import (
ESMFold2InputBuilder, StructurePredictionInput,
ProteinInput, DNAInput, RNAInput, LigandInput, Modification,
)
from transformers.models.esmfold2.modeling_esmfold2 import ESMFold2Model
model = ESMFold2Model.from_pretrained("biohub/ESMFold2").cuda().eval()
# or "biohub/ESMFold2-Fast" (24 layers, no MSA, ~1.7x faster)
# or "biohub/ESMFold2-Experimental{,-Fast}{,-Cutoff2025}" (4 design-critic models)
spi = StructurePredictionInput(sequences=[
ProteinInput(id="A", sequence=target_seq),
ProteinInput(id="B", sequence=binder_seq),
# DNAInput(id="C", sequence="ACGT", modifications=[Modification(position=5, ccd="C36")]),
# RNAInput(id="D", sequence="ACGU"),
# LigandInput(id="L", ccd=["SAH"]), # or smiles="..."
])
# Homodimer: ProteinInput(id=["A","B"], sequence=seq)
results = ESMFold2InputBuilder().fold(
model, spi,
num_loops=10, # paper FoldBench eval: 10; 20-loop variant: 20
num_sampling_steps=68, # paper eval: 68 (truncated EDM)
num_diffusion_samples=5, # paper eval: 5/seed
seed=0,
)
# fold() returns list[Prediction], one per diffusion sample. Each carries
# .plddt [L], .ptm, .iptm, .pae [L,L], .pair_chains_iptm, .complex.to_mmcif().
# Rank by ipTM for complexes / mean pLDDT for monomers:
best = max(results, key=lambda r: float(r.iptm if r.iptm is not None
else r.plddt.mean()))
open("pred.cif", "w").write(best.complex.to_mmcif())
Paper-faithful FoldBench settings: 10 loops, 68 sampling steps, 25 seeds
x 5 diffusion samples; rank by ipTM (complexes) or pLDDT (monomers); MSA mode
adds msa_depth=1024 with 10% column masking and ESMC dropout 0.3.
Throughput: set_kernel_backend("fused") is REQUIRED
Default is the slow path.ESMFold2Model.from_pretrained(...) loads with
_kernel_backend=None (reference PyTorch) and chunk_size=64. You MUST call:
model = ESMFold2Model.from_pretrained("biohub/ESMFold2").cuda().eval()
model.set_kernel_backend("fused") # vendored Triton TriMul/LN+SwiGLU/pair-bias kernels
model.set_chunk_size(None) # optimal & OOM-safe L<=1024; use 256 above
"fused" gives ~1.5–6× trunk speedup over the reference backend, growing with
L; end-to-end fold() is diffusion-bound at short L so fused breaks even
around L≈300–400. Fused vs reference outputs are numerically consistent (pLDDT
within noise). "fused" (Triton, bundled with the GPU torch wheel) is
inference-only — auto-disables under backprop. Above ~L=1400
(chunk_size=128) it hits illegal memory access — fall back to
set_kernel_backend(None) + set_chunk_size(64); validated through L=1024.
Do NOT useset_kernel_backend("cuequivariance"): the
cuequivariance-torch==0.10.0 wheel lacks the compiled ops and silently
falls back to the reference path. apply_torch_compile() is an
alternative (NOT additive — call set_kernel_backend(None) first).
ESMFold2-Experimental* — design hook
Experimental variants expose res_type_soft for gradient-guided design — see
references/design-hook.md. Do NOT use the fused backend with them (fp32/bf16
dtype crash; the reference path is correct).
The Kabsch alignment in modeling_esmfold2_common.py calls
torch.linalg.svd(H32, driver="gesvd") on batched 3x3 matrices. NaN/Inf inputs
(degenerate diffusion samples) corrupt the cusolver workspace — all subsequent
CUDA calls fail with "illegal memory access". Monkeypatch: redirect small
batched SVDs to CPU:
_orig_svd = torch.linalg.svd
def _safe_svd(A, full_matrices=True, driver=None):
if A.is_cuda and A.shape[-1] <= 4 and A.shape[-2] <= 4:
Acpu = A.detach().float().cpu()
if not torch.isfinite(Acpu).all():
Acpu = torch.nan_to_num(Acpu, nan=0.0, posinf=1e6, neginf=-1e6)
out = _orig_svd(Acpu, full_matrices=full_matrices)
# torch.return_types.linalg_svd is a C structseq -> ctor takes ONE tuple.
return type(out)(tuple(t.to(A.device, A.dtype) for t in out))
return _orig_svd(A, full_matrices=full_matrices, driver=driver)
torch.linalg.svd = _safe_svd
Note type(out)(tuple(...)), nottype(out)(*(...)) — torch.return_types.* are
C structseqs whose constructor takes a single tuple argument.
With-MSA mode
ESMFold2 supports per-chain MSA input via ProteinInput(id, sequence, msa=MSA).
The MSA object lives at esm.utils.msa.msa.MSA:
MSA.from_a3m(remove_insertions=True) asserts equal row lengths after
insertion removal. ColabFold a3m files often carry trailing null bytes and
off-by-one rows vs the query — tr -d '\000' and force row 0 to the exact
query sequence (or MSA.from_sequences on manually cleaned, query-length rows).
ESMFold2-Fast does NOT support MSA (single-seq only).
With-MSA mode improves AbAg interface pass-rate per the paper's evaluation.
Paper-matched inference configuration
The paper's FoldBench protocol (section A.2.11):
Parameter
Paper default
Paper "20lp"
Notes
num_loops (folding-trunk recycles)
10
20
+2pp on AbAg
num_sampling_steps (diffusion)
68
68
EDM-tuned; do NOT use 200
seeds x diffusion samples
25 x 5
25 x 5
Fig S6/S7 oracle = best-of-125
Training data cutoff
ESMFold2 and ESMFold2-Fast both use a Sept 2021 PDB training cutoff (HF
biohub/ESMFold2 README).
ESMC language model
ESMC is the Biohub successor to ESM-2; three sizes: 300M (30L), 600M (36L),
6B (80L, d=2560). HF path: AutoModelForMaskedLM.from_pretrained("biohub/ESMC-6B").
Mask token is <mask> (id 32) — use tok.mask_token. The native-SDK _
convention does NOT apply to the HF tokenizer: _ is not in the vocab and
encodes to <unk>, silently corrupting mutation scores.
Full API, mutation scoring, SAE features, contact prediction: see
references/esmc.md.
How do I install esmfold2?
Download resources/skills/esmfold2/SKILL.md from the publisher, or copy the path and open the repository. PlugMCP lists the skill and does not host the file.
Where does esmfold2 live?
The publisher keeps it at https://github.com/aipoch/open-science.
Which agents can use esmfold2?
Claude, Cursor, and Codex can read a SKILL.md you add from the publisher's repository.