Back to list

LigandMPNN Protein Design: How AI Reads the Ligand to Design Sequences

Published on November 4, 2026

LigandMPNN Protein Design: How AI Reads the Ligand to Design Sequences

Fig 1: LigandMPNN lets AI design protein sequences within the ligand's atomic environment



Lead: When the protein you want to design must bind a small molecule, a stretch of DNA/RNA, or a metal ion, sequence design can no longer just look at the backbone—it has to look at the ligand. LigandMPNN protein design is exactly that kind of AI sequence design method that reads the ligand at the atomic level.


Background & Problem: Why Traditional Methods "Can't See" the Ligand

Protein design has long faced a hard problem: when the target protein must bind a small molecule, a DNA/RNA segment, or a metal ion, sequence design cannot focus only on the protein backbone—it must also account for these nonprotein partners. Yet most prior deep-learning sequence design methods (e.g., ProteinMPNN) take mainly protein backbone atoms as input and cannot model nonprotein atoms and molecules. As a result, in enzyme, small-molecule-binder and sensor design, models often "can't see" the ligand and produce sequences that do not match the ligand's real binding environment.

LigandMPNN protein design was created to close this gap: it brings all nonprotein components of a biomolecular system into the model, so sequence design happens in an atomic environment that actually "sees" the ligand.


Principle & Mechanism: How LigandMPNN "Sees" the Ligand and Designs


LigandMPNN uses message passing to aggregate both residue nodes and ligand-atom nodes, then autoregressively outputs the sequence

 Fig 2: LigandMPNN uses message passing to aggregate both residue nodes and ligand-atom nodes, then autoregressively outputs the sequence


LigandMPNN is a sequence design model based on a message-passing neural network (MPNN) that extends the ProteinMPNN architecture. Its core mechanism:

1. Input: protein backbone coordinates (N, Cα, C, O, etc.) plus full ligand/nonprotein coordinates (small molecules, nucleotides, metals, etc.).

2. Message passing: on a 3D structure graph, residue nodes exchange information with each other and with ligand-atom nodes; the ligand's atomic environment is thereby "seen".

3. Autoregressive output: it samples amino acids residue-by-residue while also generating sidechain conformations at each position, enabling direct evaluation of binding interactions.

Importantly, LigandMPNN does not only output sequences—it also outputs sidechain conformations, giving an atomic-level basis for binding-energy evaluation and structural checks, not just a string answer.


Capability Boundary & Selection: Choosing Between LigandMPNN, ProteinMPNN, and Rosetta

In published data, LigandMPNN leads substantially on native-sequence recovery for residues that contact the ligand (values reported in the paper).

Contacting partner

LigandMPNN

Rosetta

ProteinMPNN

Small molecules

63.3%

50.4%

50.5%

Nucleotides

50.5%

35.2%

34.0%

Metals

77.5%

36.0%

40.6%

Source: Dauparas et al., Nature Methods 2025 (doi:10.1038/s41592-025-02626-1).

Selection guidance:

- Ligand-aware design is needed (enzymes, small-molecule binders, nucleic-acid binders, metalloproteins/sensors) → choose LigandMPNN.

- Pure backbone, multi-chain, oligomer, no-ligand cases → ProteinMPNN remains mature, lightweight and robust.

- Energy-function-level modeling / Rosetta workflows → Rosetta remains a complementary tool for backbone and scoring.

Be clear about LigandMPNN's capability boundary: it solves "design a sequence on a given structure (including ligand)" but does not generate new backbones. New backbones typically come from structure-generation models (e.g., diffusion-based RFdiffusion) combined with sequence design (LigandMPNN). And the designed sequences still require wet-lab (measured) validation—reported recovery rates are measured, not predicted.


Conditions & Workflow: From Structure to Sequence to Wet-Lab Validation


The LigandMPNN protein design loop structure → sequence → wet-lab test → active learning.

 Fig 3: The LigandMPNN protein design loop: structure → sequence → wet-lab test → active learning


A typical LigandMPNN protein design workflow (closed loop) is:

1. Structure preparation: provide coordinates (e.g., PDB) of the target backbone (with or without ligand).

2. Sequence design: specify which chains/positions to design, set amino-acid biases, excluded residues, fixed positions, etc., then run LigandMPNN to batch-generate candidate sequences with sidechain conformations.

3. Filter & score: rank candidates using structure prediction and energy/interaction evaluation; the concurrently generated sidechains enable direct binding assessment.

4. Wet-lab validation: express, purify, and measure activity/binding (measured); solve structure if needed.

5. Active-learning loop: feed wet-lab data back and iteratively improve structure and sequence models.

The paper reports that LigandMPNN has been used to design over 100 experimentally validated small-molecule and DNA-binding proteins (four with X-ray crystal structures), and that redesigning a set of Rosetta small-molecule binder designs increased binding affinity by as much as ~100-fold. These are published/measured results indicating experimental effectiveness.


How MatwingsVenus® Enables Practical Deployment of LigandMPNN Protein Design

Taking LigandMPNN protein design from a published method to a reproducible R&D pipeline requires engineering support for a computation–wet-lab closed loop. MatwingsVenus® provides value at this stage through:

- Dry–wet closed-loop platform: integrate structure preparation, LigandMPNN sequence design, filtering/scoring, and wet-lab data feedback into an iterable automated workflow.

- Wet-lab center: provide measured validation for design candidates—expression, purification, activity/binding assays and structure determination—so the "compute → measure" loop truly closes.

- Expert center: help with method selection (LigandMPNN / ProteinMPNN / Rosetta), constraint setup, failed-experiment diagnosis, and multi-mutant batch planning.

In practice, whether to use ligand awareness, how to set fixed residues and amino-acid biases, and how to design assays with distinguishable readouts at the wet-lab end are often the keys to project success—exactly where an engineered platform and expert experience add value.


FAQ

What is the difference between LigandMPNN and ProteinMPNN?

The core difference is "whether it can see the ligand." ProteinMPNN mainly inputs protein backbone atoms (N, Cα, C, O, etc.), whereas LigandMPNN explicitly models all nonprotein components—small molecules, nucleotides, metals—so it leads on native-sequence recovery for ligand-contacting residues (e.g., metals 77.5% vs 40.6%) [measured].

Can LigandMPNN generate new protein backbones by itself?

No. LigandMPNN is a sequence design model that designs amino-acid sequences on a given structure (including ligand); it does not generate new backbones. New backbones are typically produced by structure-generation models (e.g., diffusion-based RFdiffusion), then handed to LigandMPNN for sequence design.

Are sequences designed by LigandMPNN always effective?

Not necessarily—they need measured validation. LigandMPNN returns computational design candidates that still require wet-lab confirmation (expression, purification, activity/binding assays, structure determination when needed). The 100+ experimentally validated cases in the paper are measured results, but not every candidate is guaranteed to succeed.

Can I use LigandMPNN without ligand coordinates?

You can, but the value drops. LigandMPNN's main advantage comes from sensing ligand/nonprotein atoms; with only a pure protein backbone it behaves close to ProteinMPNN. It is most worthwhile for true ligand-aware scenarios (enzymes, binders, metalloproteins).

What inputs does LigandMPNN require?

It needs structure coordinates (e.g., PDB) with protein chains and ligand info that can be parsed, plus optional constraints such as which chains/positions to design, fixed residues, amino-acid biases, and excluded residues. Structure quality matters—a crude or ligand-missing structure lowers sequence quality.

Which scenarios best suit LigandMPNN?

Protein design that needs small-molecule/nucleotide/metal awareness, e.g., enzyme engineering, small-molecule binders, nucleic-acid-binding proteins, metalloproteins and sensors. For pure-backbone multi-chain/oligomer design, the lighter ProteinMPNN is more appropriate.

Can MatwingsVenus® help me run LigandMPNN?

Yes. The platform integrates it into the dry–wet closed-loop platform plus expert and wet-lab services: from structure preparation, sequence design and constraint setup, to candidate filtering, wet-lab validation and data feedback—end-to-end engineering support.


Conclusion

The value of LigandMPNN protein design is that it is among the first mainstream deep-learning sequence design methods to "see" the ligand at the atomic level, delivering higher sequence recovery and more realistic binding-environment modeling for enzyme and small-molecule/nucleic-acid/metal-binding protein design. It is not a silver bullet—it does not generate backbones, and results still need wet-lab validation—but combined with method selection and an engineered closed loop (MatwingsVenus® dry–wet closed-loop platform, wet-lab center, expert center), LigandMPNN protein design is becoming an indispensable part of protein engineering.

【One-sentence conclusion】 LigandMPNN uses atomic-context conditioning so that AI designs protein sequences while actually "seeing" the ligand (small molecule, nucleic acid, or metal), making it one of the most important methods for enzyme and small-molecule-binding protein design.


(LigandMPNN data in this article are from the published paper "Atomic context-conditioned protein sequence design using LigandMPNN", Nature Methods, 2025; Figures 1–3 are illustrative/schematic, not to scale, and do not depict a specific validated structure.)


Scan to join community

Scan to join community