BoltzGen, a new diffusion model that generates de novo molecules from scratch which binds to other proteins, peptides, nanobodies, disulfide-cyclized peptides, helicons, cyclic peptides, and protein binders for small molecules, nucleic acids, disordered regions, and folded protein targets. That’s why it’s called an universal binder. It consists of:
- BoltzGen (the diffusion model which generates de novo structures)
- BoltzIF (for inverse folding, given this fold, what sequence would actually stabilize it?)
- Boltz-2 it refolds the designed sequence, checks whether the structure holds together, estimates binding affinity, and evaluates interface quality through buried surface area, hydrogen bonds etc.)
BoltzGen doesn’t treat proteins as tokens like Large Language Models. It treats them as physical objects that only make sense in three dimensions as amino acid residues are in certain order and folded in 3D space.
So how did they solve it?
14 atoms representation
Amino acids has different size and shapes. Glycine barely has a sidechain at all. Tryptophan has a large aromatic component. Diffusion models don’t like that chaos.
When BoltzGen is designing a residue, it doesn’t yet know whether that position will become an Alanine or a Threonine. Each amino acid has a different number of atoms, from 1–20 atoms on its sidechain. That’s the problem, the model needs a fixed-size structure (same number of atoms every time), otherwise you can’t diffuse coordinates in a consistent vector space.
BoltzGen’s solution:
Each designed residue is temporarily represented using exactly 14 atoms, regardless of which amino acid it will eventually become.
- 4 atoms are real backbone atoms: N, CA, C, O
- The remaining 10 atoms are “virtual” placeholders. The model signals which amino acid it wants by placing a specific number of these virtual atoms directly onto the backbone atoms (on top of N and O). Then it decode the amino acid identity by counting how many virtual atoms land on each backbone position (within 0.5 Å).
After generation finishes:
- virtual atoms are discarded
- a real amino acid identity is decoded from their positions
How the model actually turns the 14-atom placeholder into the final real amino acid geometry?
Diffusion is a cloud, once the model finish diffusion, it has 14 residues as I have mentioned earlier. The system has to translate that cloud into: a real amino acid with a real sidechain which doesn’t break chemistry. Let’s understand this with Threonine example:
Each amino acid has a unique pattern like a barcode. Threonine is encoded by placing 3 virtual atoms on the backbone nitrogen, and 4 virtual atoms on the backbone oxygen.
- Fixed atoms (backbone) which always exists: N,CA, C, O
- Virtual atoms (atoms 5–14)
- BoltzGen needs to signal the residue identity using atoms 5–14
So the threonine encoding looks like:
N atom: N + 3 virtual atoms
CA atom: (just CA)
C atom: (just C)
O atom: O + 4 virtual atoms
Sidechain: 3 atoms left → CB, OG1, CG2
For threonine, check how many virtual atoms are within 0.5 Å of:
- 3 virtual atoms placed exactly on top of the N atom
- 4 virtual atoms placed exactly on top of the O atom
- Remaining 3 virtual atoms become real sidechain atoms (CB, OG1, CG2) where CB = beta carbon; OG1 = hydroxyl oxygen branch; CG2 = second carbon branch of threonine’s side chain.
Diffusion doesn’t guarantee perfect bond lengths or ideal chirality, so the model runs a local cleanup pass where bonds are corrected, angles restored to restore chemistry.
How the Diffusion Process Works?
Diffusion models can only operate on fixed-size representations. As I have discussed above, BoltzGen solves this by giving every designed residue a temporary, uniform 14-atom representation.
Diffusion treats all atoms equally i.e. the diffusion model sees just a cloud of 3D points with element/charge/type embeddings. It doesn’t know which atoms are virtual; that’s only used in decoding afterward. With iterative denoising:
- the denoiser predicts the positions of all 14 atoms
- their arrangement will encode residue identity via geometry
- the denoiser learns the patterns that correspond to valid amino acids
Why virtual atoms encode residue identity so effectively?
During training, the model repeatedly encounters the same geometric signatures that distinguish one amino acid from another.
- “3 near N + 4 near O = Threonine”
- “7 near O = Proline”
- “0/0 for N/O + symmetric sidechain = Glycine”
These configurations repeatedly appear in real proteins. The diffusion model learns that reproducing them reduces structural error, incorrect patterns (wrong amino acids) increase the Mean Squared Error (MSE) and local Distance Difference Test (lDDT) errors. As a result, it naturally produces these patterns during generation.
But why 14 atoms? Why not 10 or 20?
Simply, to support the largest residues without running out of space, you need:
Backbone: 4 atoms
Max sidechain atoms needed: 13
Total theoretical max = 17
Thus 14 atoms is:
- small enough to be computationally efficient
- large enough to represent the largest residues
- flexible enough for geometric encoding patterns
- consistent with Boltz-2 and AlphaFold3 architecture constraints
Why this representation enables better structure prediction and binder design?
A single, continuous representation means BoltzGen never has to switch modes when the task changes. Every proteins, peptides, nucleic acids, small molecules enters the model as same type of object: an all-atom point cloud.
Most importantly, binders and targets are folded together because the model treats them as a single atomic system. It does not fold the target first and design the binder afterward, it resolves both simultaneously through one diffusion trajectory. Interface geometry, hydrogen-bonding patterns, shape complementarity, and buried area all emerge from the same process.
BoltzGen Protocols
There are four protocols:
- protein-anything for designing proteins to bind protein/peptide targets
- peptide-anything for designing peptides to bind protein targets
- protein-small molecule for designing proteins to bind small molecules
- nanobody-anything for designing nanobodies
Below protocol is focused, practical guide to run peptide-anything on an HPC cluster so anyone can reproduce, tune, and inspect results. It covers YAML examples, key CLI flags, recommended settings, HPC tips, what the outputs mean, and minimal troubleshooting.
BoltzGen samples 3D all-atom structures with virtual placeholders, converts them to sequences (BoltzIF), refolds and scores them (Boltz-2), then ranks/filter designs — peptide-anything constrains the design to short peptide binders.
Typical pipeline steps (seven logical stages)
- Design : diffusion generation of candidate binder structures (BoltzGen core).
- Inverse folding : generate sequences (BoltzIF).
- Design folding : refold binder+target to validate interface (Boltz-2).
- Folding : refold binder alone (for stability; often skipped for short peptides).
- Affinity: (optional for small molecules) estimate affinity.
- Analysis : compute interface metrics (buried SASA, H-bonds, salt bridges, plip).
- Filtering : rank and select diverse, high-quality candidates.
You can run all stages or any subset. For peptides you typically run: design → inverse_folding → design_folding → analysis → filter
Folding-alone can be skipped for very short peptides or nanobodies (default for peptide-anything).
Table 1: Key CLI flags
Table 2: Common output metrics
Notes:
- pTM/pLDDT from Boltz-2 are primary confidence metrics. Use higher values for initial triage
- RMSD(design → refold) close to zero indicates the sequence refolds to the designed geometry, lower is better.
Table 3: Design Quality Thresholds
Minimal recommended settings for a first peptide run
- protocol: peptide-anything
- num_designs: 10,000 (start small) → scale to 30–60k for production.
- budget: 20–50 (final candidates)
- alpha: 0.01 (peptide default)
- steps: design,inverse_folding,design_folding,analysis,filter
- GPUs: ≥16 GB recommended to start; distribute -num_designs across jobs on HPC
Conclusion
BoltzGen works the way structural biology actually works: geometry first. It forces the model to justify every atom, then keeps only the sequences that survive folding, refolding, and the usual structural abuse. Diffusion, inverse folding, and refolding lock together into a single, compact engine that has the leverage to become the baseline for reliable structure generation.
if you love reading about biotech x AI, follow me on twitter/X @TensorTwerker : I share insights on protein modeling, computational biology, and the occasional chaos that happens in my life.