RFantibody

Design antibody and nanobody binders with an end-to-end RosettaCommons pipeline

Job name

Target antigen structure

HLT antibody framework

250 credits

Configure input settings on the left, then click "Submit job"

What is RFantibody?

RFantibody is a structure-guided antibody and nanobody design pipeline built around an antibody-tuned version of RFdiffusion. It generates new CDR-mediated binding geometries against a chosen epitope, designs compatible loop sequences, and then filters the resulting complexes with an antibody-tuned RoseTTAFold2 model.

The method was introduced as a route to de novo, epitope-specific antibody design from structural input rather than immunization or random library discovery. In the published workflow, the computational design stage is followed by experimental screening, because the model can generate structurally accurate binders but still requires broad sampling to recover the strongest candidates.

How to use RFantibody online

ProteinIQ runs RFantibody on hosted GPU infrastructure, so the full three-stage pipeline can be launched from the browser without installing RosettaCommons dependencies locally.

The online interface accepts one target structure and one antibody or nanobody framework. The target can be uploaded as a PDB/ENT file or fetched from the RCSB. The framework must already be prepared in RFantibody's HLT format.

Inputs

Input	Description
`Target antigen structure`	Antigen PDB or ENT structure, uploaded directly or fetched from the RCSB by PDB ID. Large targets should usually be truncated around the intended epitope because runtime scales poorly with target size.
`HLT antibody framework`	Antibody or nanobody framework PDB in RFantibody HLT format. This is not a generic antibody structure file; it must use RFantibody chain conventions and CDR loop remarks.

HLT framework requirements

Requirement	Description
Heavy chain	Must use chain ID `H`. For nanobodies, the single variable domain is treated as the heavy chain framework.
Light chain	If present, must use chain ID `L`. Nanobody frameworks omit this chain.
Chain order	Protein chains should appear in `H` then `L` order. In full HLT complexes, target chains are represented as `T`.
Loop remarks	The file must end with `REMARK PDBinfo-LABEL` annotations that mark the absolute residue indices of the CDR loops, for example `REMARK PDBinfo-LABEL: 32 H1`.
Accepted examples	native example frameworks include the nanobody file `h-NbBCII10.pdb` and the antibody Fv file `hu-4D5-8_Fv.pdb`.

Generic antibody PDB files usually do not include those loop remarks or chain conventions. In the native RFantibody workflow, such structures are converted to HLT format before design.

Design settings

Setting	Description
`Backbone designs`	Number of backbone dock designs to generate in the RFdiffusion stage (1-10, default `10`).
`Sequences per backbone`	Number of ProteinMPNN sequence variants to sample for each designed backbone (1-8, default `1`).
`Sequence temperature`	ProteinMPNN sampling temperature (0.1-1.0, default `0.1`). Lower values bias toward more conservative loop sequences.
`RF2 recycles`	Number of RoseTTAFold2 recycling iterations used during filtering (1-20, default `10`).
`Deterministic mode`	Requests deterministic sampling where supported, useful for reproducible pilot runs.

CDR loop ranges

Setting	Description
`Design H1/H2/H3`	Toggles for heavy-chain CDR loop design. Enabled by default, matching `H1:,H2:,H3:` behavior.
`H1/H2/H3 length`	Optional heavy-chain CDR length or length range, such as `7` or `5-8`. Leave blank to design that loop at the native framework length.
`Design L1/L2/L3`	Toggles for light-chain CDR loop design. Enabled by default; native skips these loops for nanobody frameworks without chain `L`.
`L1/L2/L3 length`	Optional light-chain CDR length or length range for antibody frameworks. Leave blank to design the loop at the native framework length.

At least one loop must be enabled. To keep a loop fixed, turn off its design toggle. A blank length on an enabled loop does not skip the loop; it uses the native length syntax such as H1:.

Targeting

Setting	Description
`Hotspot residues`	Comma-separated antigen residues such as `B146,B170,B177`. These residues bias the model toward a particular epitope. Bad hotspot definitions can produce undocked designs, so small pilot runs are usually preferable before scaling up.

Advanced settings

Setting	Description
`Diffusion timesteps`	RFdiffusion denoising steps passed as `--diffuser-t` (default `50`).
`Final diffusion step`	Final RFdiffusion step passed as `--final-step` (default `1`).
`Return RFdiffusion trajectory`	Returns native RFdiffusion trajectory quiver files. Enabled by default, matching native trajectory output.
`Omitted amino acids`	ProteinMPNN `--omit-aas` value (default `CX`).
`ProteinMPNN noise`	Optional ProteinMPNN `--augment-eps` coordinate noise. Leave blank to use the command-line default.
`RF2 hotspot visibility`	Fraction of hotspot residues shown to RF2 during filtering (default `0.1`).
`RF2 random seed`	Optional RF2 seed. Leave blank for stochastic RF2, or enable deterministic mode to use seed `42`.

Outputs

Output	Description
Designed complexes	Final antibody-antigen or nanobody-antigen complexes in PDB format.
Final score file	`.sc` score table exported from the final RF2 quiver output.
Stage quiver files	RFdiffusion, ProteinMPNN, and RF2 quiver files for downstream inspection.
RFdiffusion trajectory	`Xt-1` and `pX0` trajectory quiver files when trajectory output is on.
File table	Downloadable list of all generated design files.

How does RFantibody work?

RFantibody runs three design stages in sequence.

Antibody-tuned RFdiffusion

The first stage places a chosen framework against the target and redesigns the selected CDR loops. Rather than generating an arbitrary binder scaffold from scratch, this stage treats the framework as fixed context and focuses the generative step on loop-mediated docking and backbone creation around the target epitope.

ProteinMPNN sequence design

Once loop backbones have been generated, ProteinMPNN samples amino acid sequences compatible with each designed structure. In RFantibody, this step is used to populate the redesigned loops while preserving the broader framework context.

Antibody-tuned RF2 filtering

The final stage predicts the structures of the designed sequences in complex with the target and scores whether the intended interface appears self-consistent. This filtering stage is important because antibody design campaigns generally require broad sampling, and only a subset of computational designs retain the desired dock after structure prediction.

Interpreting results

RFantibody output is best treated as a ranked candidate set rather than a final answer. Structural inspection still matters: plausible designs should maintain a well-packed interface, avoid obvious clashes, and keep the framework geometry reasonable outside the redesigned loops.

The native guidance recommends filtering designs with strong RF2 confidence and low disagreement between the design model and the RF2-predicted complex. In practice, RF2 pAE below roughly 10 and design-versus-prediction RMSD below roughly 2 Å are used as minimal screening criteria before downstream experimental work or more detailed physics-based evaluation.

Applications

Epitope-specific nanobody design: Generating VHH binders against structurally defined target surfaces.
Antibody variable-domain design: Designing scFv-like variable regions with both heavy- and light-chain CDR participation.
Targeted campaign exploration: Running pilot campaigns to compare hotspot definitions, loop ranges, or framework choices before large-scale screening.

Related tools

Proteo-R1

Reasoning-guided antibody CDR co-design for antibody-antigen complexes. Proteo-R1 identifies residue-level functional decisions and uses conditional diffusion to generate ranked designed structures with confidence metrics.

BioPhi

Antibody humanization and humanness evaluation platform from Merck. Sapiens mode uses deep learning trained on the Observed Antibody Space (OAS) to humanize antibody sequences, while OASis mode evaluates humanness using 9-mer peptide search against human antibody databases.

BoltzGen

BoltzGen is a state-of-the-art AI model for designing protein and peptide binders against any biomolecular target. Using generative diffusion models, it creates novel binders (proteins, peptides, nanobodies) with nanomolar-level binding affinity.

DiffAb

AI-powered antibody CDR design using equivariant diffusion models. Generates optimized complementarity-determining region (CDR) sequences and structures for antibodies targeting specific antigens. Supports single CDR, multi-CDR co-design, and fixed-backbone sequence design modes.

PepMLM

Design linear peptide binders for target proteins using a target sequence-conditioned masked language model. PepMLM generates peptide sequences optimized to bind specific protein targets based on ESM-2 protein language modeling.

EvoDiff

EvoDiff is a diffusion-based protein sequence generation framework from Microsoft Research. ProteinIQ currently wraps the EvoDiff-Seq OA_DM_38M model for unconditional protein generation, motif scaffolding, and user-sequence inpainting.

ODesign

All-atom generative AI for designing protein binders. Specify target binding sites and generate diverse binding proteins with fine-grained control over interaction parameters.

PocketFlow

PocketFlow is a structure-based molecular generative model that designs novel drug-like molecules within protein binding pockets. It uses autoregressive flow modeling with chemical knowledge to generate 100% chemically valid, highly drug-like compounds.

PocketXMol

PocketXMol is a pocket-interacting generative foundation model for docking, small-molecule design, and peptide design in protein binding pockets.

RFdiffusion

RFdiffusion is a state-of-the-art protein structure generation tool that uses diffusion models to design proteins de novo, create binders, scaffold motifs, and generate symmetric oligomers with atomic precision.