RFD4-Proteina: How NVIDIA and the Baker Lab Turned Protein Design Into a Search Problem

Designing a protein that binds a specific target, catalyzes a reaction, or folds into a precise shape has historically required years of wet-lab iteration. Computational tools have compressed that timeline, but even the best generative models still produce thousands of candidates that must be screened after the fact. RFD4-Proteina, released on October 20, 2026, by NVIDIA and the Institute for Protein Design at the University of Washington, takes a different approach: it treats protein design as an active search problem, pruning bad trajectories during generation rather than filtering them afterward.

The result is a 435-million-parameter open-weights model that outperforms previous methods by wide margins on four benchmark suites — and does so while using 84% less peak GPU memory than its predecessor.

What the Model Actually Does

RFD4-Proteina is a latent-space flow-matching generative model. Rather than predicting a protein structure from a sequence (the classic folding problem), it works in the opposite direction: given a design specification — a binding target, a catalytic site, a small-molecule ligand — it generates both the protein sequence and the corresponding all-atom 3D structure simultaneously.

The architecture has two main components: a 178-million-parameter trunk that runs inside a latent space, and a 256-million-parameter autoencoder that maps between that latent space and explicit backbone coordinates. By operating at the residue level rather than the atom level, the model compresses the representation enough to complete a generation in 60 sampling steps — compared to roughly 400 steps required by earlier methods like Proteina-Complexa.

The model supports seven distinct design tasks:

• De novo generation of monomers or conditional designs
• Motif scaffolding — building a protein scaffold around a specified functional segment
• Enzyme design — generating scaffolds around catalytic sites
• Small-molecule binder design — wrapping a protein around a ligand
• Antibody/TCR design — redesigning CDR loops on fixed frameworks
• Partial diffusion — refining an existing design by re-initiating the process mid-trajectory
• Inverse folding — resampling sequences for a fixed backbone

The Core Innovation: Reward-Guided Beam Search

Most generative protein design workflows follow a simple pattern: sample many candidates, then filter. This works, but it wastes compute on trajectories that were never going to produce a viable design.

RFD4-Proteina replaces that pattern with reward-guided inference-time search. During the denoising process, the model pauses at defined step checkpoints — for example, at steps 0, 20, 40, 50, and 60. At each checkpoint, surviving candidates are branched: each branch is rolled out to a complete structure and scored against an objective. Only the top candidates (controlled by a beam_width parameter) continue to the next stage.

The scoring is done by CUDA-accelerated external oracles. The default integration uses OpenFold3 for structural confidence (pLDDT scores) and TMol for physics-based interaction metrics. Researchers can plug in custom reward functions as callbacks, making the search adaptable to specific design goals.

This is meaningfully different from best-of-N sampling. In best-of-N, you generate N complete structures and pick the best one. In beam search, you prune at intermediate steps, concentrating compute on trajectories that are already showing promise. The practical effect: at 200 residues, RFD4-Proteina is 3.8x faster than RFD3 and uses 84% less peak reserved memory.

Benchmark Results

The performance gap over previous methods is substantial. On a frozen benchmark run from October 9, 2026, RFD4-Proteina (High Thinking mode) achieved the following design efficiency scores:

These are not marginal improvements. The protein binder score is more than 5x the next-best method; the small-molecule binder score is more than 7x. Part of this gap reflects the reward-guided search itself — the model is not just better at generating candidates, it is better at finding the good ones within a fixed compute budget.

How to Use It

RFD4-Proteina is available through three channels:

1. Open weights on Hugging Face (nvidia/RFD4-Proteina) under a BSD 3-Clause license, in both native and diffusers-compatible formats
2. NVIDIA NIM microservice — a production-ready API wrapper with BioNeMo Inference Runtime acceleration
3. RosettaCommons GitHub — the reference implementation with full documentation for reward-guided search configuration

The model requires Linux x86_64, Python 3.12, and an NVIDIA GPU with a CUDA 13-compatible driver. The weights are stored in FP32 and run in BF16 at inference time. Full setup instructions and example notebooks are available in the RosettaCommons/RFD4-Proteina GitHub repository.

For reward-guided search, the key parameters are beam_width (how many candidates survive each checkpoint), n_branch (how many branches to create at each checkpoint), and step_checkpoints (which denoising steps trigger scoring). A typical experimental configuration uses a beam width of 3 and 2 branches per checkpoint.

Why This Architecture Matters

The shift from post-hoc filtering to in-trajectory search reflects a broader pattern in generative AI: inference-time compute is increasingly being used to improve output quality without retraining. In language models, this shows up as chain-of-thought reasoning, tree-of-thought search, and process reward models. RFD4-Proteina applies the same logic to protein design — the model's "thinking" happens during the diffusion trajectory, guided by external oracles that encode domain knowledge.

The open-weights release under BSD 3-Clause is also notable. Protein design tools have historically been locked behind institutional access or commercial APIs. Making the weights freely available for commercial use lowers the barrier for biotech startups and academic labs that want to build on top of the model rather than use it as a black box.

The NVIDIA developer blog post and the model card on NVIDIA Build both include worked examples of reward-guided search configurations, including how to integrate custom oracles and interpret the output confidence scores.

Practitioner Implications

For researchers already using RFD3 or Proteina-Complexa, the upgrade path is straightforward: the model is available through the same NIM API surface, and the open weights are compatible with existing RosettaCommons tooling. The memory reduction alone (84% less peak VRAM at 200 residues) makes it practical to run on workstation-class hardware that would have struggled with earlier versions.

For developers building protein design pipelines, the reward-guided search API is worth understanding in detail. The ability to plug in custom scoring functions — not just the built-in OpenFold3 and TMol oracles — means the search can be adapted to application-specific objectives: binding affinity predictions, solubility scores, or experimental assay proxies.

The model's support for seven distinct design tasks in a single set of weights also simplifies pipeline architecture. Rather than maintaining separate models for binder design, enzyme scaffolding, and inverse folding, a single RFD4-Proteina deployment can handle all of them.

Protein design is still a hard problem. But RFD4-Proteina demonstrates that treating generation as search — and investing compute in trajectory pruning rather than post-hoc filtering — can produce substantial efficiency gains without sacrificing output quality.