ProteinMPNN Inverse Folding: What Sequence Recovery Does and Doesn't Predict

Sequence recovery is a model-selection metric that people read as a success rate. On backbones taken from solved structures, ProteinMPNN recovers the native amino acid at 52.4% of positions, against 32.9% for Rosetta's physically-based design. That number is real, reproducible, and the reason the method displaced energy-function design for most sequence work. What it does not tell you is whether the sequences you are about to order will express, fold, or do anything. Recovery is measured where the answer is already known; your design problem is the case where it is not. The filter that has actually been shown to raise experimental success rates is different: refold every design with a structure predictor and keep only those whose predicted structure returns the backbone you designed onto.

This article is about reading that gap correctly — what recovery is evidence for, what it is silent on, and which in silico checks carry real signal about expression and folding.

What Inverse Folding Computes#

Fixed-backbone design asks: given coordinates, which sequence folds into them? ProteinMPNN answers with a message-passing network over a nearest-neighbour graph of backbone atoms, decoding residue identities in a random order so each position is chosen in the context of the positions already decided. The free decoding order is what makes the method practical: positions can be held fixed, tied across chains for symmetric assemblies, or biased toward particular residues, so you can redesign part of a protein and leave the rest alone.

Two things are worth being clear about before any number is quoted.

The backbone is an input, not an output. Inverse folding is the sequence half of protein design. Coordinates arrive from an experimental structure, a prediction, or a generative backbone model such as RFdiffusion, and the model treats them as truth. A loop modelled into weak density, a low-confidence predicted region, or a generated backbone that is not actually designable all produce confident sequences for a shape that may not be real.

The model scores sequence likelihood, not function. The per-design score says the sequence fits the backbone under the model. It is not a binding prediction, not a stability prediction, and not an expression prediction, and it should never be reported as one.

The Benchmark, and Its Boundaries#

The ProteinMPNN paper's own evidence runs down that table rather than stopping at the top row: alongside the 52.4%-versus-32.9% recovery comparison, it reports X-ray crystallography, cryo-electron microscopy and functional studies, including rescuing designs that had previously failed when made with Rosetta or AlphaFold, across monomers, cyclic homo-oligomers, tetrahedral nanoparticles and target-binding proteins. The recovery figure is the headline; the structures are the argument.

Why Recovery Underestimates Some Designs and Flatters Others#

Recovery is a comparison against one reference sequence, and that reference is not the only right answer. Several distinct effects follow.

Disagreement is not error. Many sequences fold into the same backbone. A model that proposes a different hydrophobic core packing, or a different surface residue at a solvent-exposed position, is penalised by recovery even when its proposal is as good as the native one — sometimes better, which is precisely the case when the goal is to stabilise a protein rather than reproduce it.

Positions are not equally hard. Buried core positions are strongly constrained by the backbone and are recovered at high rates; exposed surface positions are weakly constrained and recovered poorly. A whole-protein recovery figure is therefore an average over a mixture, and two proteins with the same recovery can differ entirely in which half of that mixture they got right. The same arithmetic is why context-aware variants of the family report recovery at a subset of positions: the LigandMPNN paper, which models non-protein atoms, reports recovery at residues interacting with small molecules, nucleotides and metals of 63.3%, 50.5% and 77.5%, against 50.5%, 34.0% and 40.6% for ProteinMPNN on those same interacting residues (Dauparas et al., Nature Methods 2025). Those are not comparable to the 52.4% whole-backbone figure, and treating them as one scale is the most common misreading in this literature.

The benchmark's backbones are not your backbone. Native backbones come from proteins that folded, expressed and crystallised. A de novo backbone has passed none of those filters, so recovery measured on the former transfers to the latter as a direction, not a rate.

Nothing in the metric sees your construct. Expression depends on the host, the codon usage, the tags, the purification, the buffer and the protein's own aggregation behaviour. The training set is also a lever here: a model trained on the whole structural database has learned the surface chemistry of membrane proteins too, which is the rationale behind SolubleMPNN, described in the LigandMPNN repository as a ProteinMPNN-like model trained with only soluble proteins in its training dataset. That is a training-set argument with a clear mechanism, not a published effect size — there is no benchmark number attached to it the way 52.4% is attached to ProteinMPNN.

The Filter That Does Predict Success#

The step with a published, quantified effect on experimental outcomes is the refold check. In a binder-design study, using AlphaFold2 or RoseTTAFold to assess both the probability that a designed sequence adopts the intended monomer structure and the probability that this structure binds the target as designed increased design success rates nearly tenfold; the same work reports that using ProteinMPNN rather than Rosetta for the sequence step considerably increases computational efficiency (Bennett et al., Nature Communications 2023).

Read that as the shape of the method rather than as two independent facts. The value of a fast inverse-folding model is not that each sequence is better; it is that you can afford to generate many and throw almost all of them away. The discriminating power lives in the predictor, so the practical loop is:

1. Fetch or generate a backbone.
2. Design tens of sequences onto it at low sampling temperature.
3. Predict a structure for each design.
4. Compare each prediction to the backbone you designed onto, and read the predictor's own confidence while you are there.
5. Order a handful from the top of that ranking — not from the top of the design score.

Steps 3 and 4 are where designs are actually selected. Skipping them moves the filter to the bench, where each test costs orders of magnitude more than a prediction. Two caveats keep this honest: the predictor and the designer share training data and failure modes, so agreement is weaker evidence than it looks; and a confident refold says the sequence folds, not that it binds.

How to Run ProteinMPNN on .bloom*#

proteinmpnn_design runs standard ProteinMPNN as a GPU job. You give it the chains to redesign plus exactly one structure reference: the stored reference carried by a prior PDB download, the full PDB file text, or a bare four-character PDB ID you downloaded in the same session. It runs without an account.

Getting the backbone first. Fetch an experimental structure with the PDB tools (PDB docs, quickstart), or predict one from sequence with ESMFold. The general shape of job submission is in how tools run, and which tool? maps a goal onto a job; the structure prediction overview covers the trade-offs between coordinate sources.

The controls that matter. num_sequences sets how many designs come back; temperature trades conservatism for diversity, and low is the right default; backbone_noise adds coordinate noise for robustness; fixed chains are excluded from redesign. The checkpoint variant is selectable — v_48_002, v_48_010, v_48_020 (the default) and v_48_030 are the same model trained with 0.02 Å, 0.10 Å, 0.20 Å and 0.30 Å of backbone noise, so prefer a higher-noise checkpoint when your coordinates are predicted or generated and a lower-noise one when they are a high-resolution crystal structure. The job runs standard ProteinMPNN only: there is no ligand mode on it.

What comes back. The designed sequences, each with a score and a recovery rate, plus a scores CSV and the mean recovery across the run. A single-chain run producing eight sequences is on the order of ten to twenty seconds of compute, which is the fact that makes sample-many-and-filter affordable. A representative run of eight sequences reported a mean recovery of 0.545 and a best score of 1.068 in about sixteen seconds — note that the per-run mean recovery sits in the same range as the published benchmark, which is a sanity check on the run, not a prediction about the designs.

Then refold. Predict a structure for your top designs and compare it to the backbone you designed onto, reading ESMFold's confidence output alongside the geometry. That comparison, not the design score, is what should decide which sequences get ordered. If you want stability predictions for point mutations on an existing sequence, that is a different question and a different job.

For related reading: ESMFold vs AlphaFold on where predicted backbones are and are not trustworthy, and binding pocket prediction on predicted vs experimental structures on how much the coordinate source changes what you see.

Key Takeaways#

• 52.4% versus 32.9% is a model comparison, measured on native backbones against Rosetta. It is not a success rate and not a per-design probability.
• Disagreeing with the native sequence is not an error — many sequences fold into one backbone, and recovery penalises the good alternatives along with the bad.
• Whole-protein recovery averages over easy buried positions and hard exposed ones, so two proteins at the same recovery can be right about different things.
• Subset recovery numbers are not comparable to whole-backbone numbers. Interacting-residue figures answer a different question.
• The refold check is the filter with a published effect — nearly tenfold on binder-design success rates when structure prediction is used to score designs.
• Sample many, filter hard. Inverse folding is seconds of compute; the experiment is not.
• The decision-grade measurement is soluble expression plus a measured affinity or activity. Everything above it is a proxy.

Fetch or predict a backbone, design onto it, and refold the designs before you order anything — on the .bloom* platform.

References#

1. Dauparas, J., Anishchenko, I., Bennett, N. et al. "Robust deep learning–based protein sequence design using ProteinMPNN." Science 378, 49–56 (2022). doi:10.1126/science.add2187 · code: dauparas/ProteinMPNN
2. Dauparas, J., Lee, G.R., Pecoraro, R. et al. "Atomic context-conditioned protein sequence design using LigandMPNN." Nature Methods 22, 717–723 (2025). doi:10.1038/s41592-025-02626-1 · code: dauparas/LigandMPNN
3. SolubleMPNN model type and checkpoints, documented in the LigandMPNN repository as a "ProteinMPNN-like model with only soluble proteins in the training dataset." dauparas/LigandMPNN
4. Bennett, N.R., Coventry, B., Goreshnik, I. et al. "Improving de novo protein binder design with deep learning." Nature Communications 14 (2023). doi:10.1038/s41467-023-38328-5
5. Watson, J.L., Juergens, D., Bennett, N.R. et al. "De novo design of protein structure and function with RFdiffusion." Nature 620, 1089–1100 (2023). doi:10.1038/s41586-023-06415-8 · code: RosettaCommons/RFdiffusion
6. Alford, R.F., Leaver-Fay, A., Jeliazkov, J.R. et al. "The Rosetta All-Atom Energy Function for Macromolecular Modeling and Design." Journal of Chemical Theory and Computation 13, 3031–3048 (2017). doi:10.1021/acs.jctc.7b00125