For training we use all PDB structures [Berman et al., 2000] released before 2021-09-30 (same training cut-off date as AlphaFold3) and with a resolution of at least 9Å. We parse the Biological Assembly 1 from these structures from their mmCIF file. For each polymer chain, we use the reference sequence and align it to the residues available in the structure. For ligands, we use the CCD dictionary to create the conformers and to match atoms from the structure. We remove leaving atoms when (1) the ligand is covalently bound and (2) that atom does not appear in the PDB structure. Finally, we follow the same process as AlphaFold3 for data cleaning, which includes the ligand exclusion list, the minimum number of resolved residues, and the removal of clashing chains.

We construct MSAs for the full PDB data using the colabfold_search tool [Mirdita et al., 2022] (which leverages MMseqs2 [Steinegger and Söding, 2017]), using default parameters (versions: uniref30_2302, colabfold_envdb_202108). We then assign taxonomy labels to all UniRef sequences using the taxonomy annotation provided by UniProt [Consortium, 2015]. For the initial molecular conformers that are provided to the model, we pre-compute a single conformer for all CCD codes using the RDKit’s ETKDGv3 [Wang et al., 2022].

We train the structure prediction model (see Section 3.2 for details of the confidence model training) for a total of 68k steps with a batch size of 128. During the first 53k iterations, we use a crop size of 384 tokens and 3456 atoms and draw structures equally from the PDB dataset and the OpenFold distillation dataset (approximately 270K structures, using the MSAs they provided) [Ahdritz et al., 2024]. For the last 15k iterations, we only sampled from the PDB structures and had a crop size of 512 tokens and 4608 atoms. As a comparison AlphaFol3 trained a similar architecture for nearly 150k steps with a batch size of 256, which required approximately four times the computing time. We attribute some of this drastic reduction to the various innovations we detail in the remainder of this section and the next.

We find it beneficial to reorder the operations performed in the MSAModule (AlphaFold3 Algorithm 8) to better allow the updates on the single and pair representations to feed to one another. In particular, we change the order³ of its operations from:

OuterProductMean, PairWeightedAveraging, MSATransition, TriangleUpdates, PairTransition to:

PairWeightedAveraging, MSATransition, OuterProductMean, TriangleUpdates, PairTransition. Note that OuterProductMean propagates information from the single to the pair representation, so we now allow the single representations learned in the MSATransition to directly propagate to the pair representation.

Abramson et al. [2024] presents an unusual order of operations in their DiffusionTransformer layers where hidden representations are updated as (AlphaFold3 Algorithm 23):

This has two issues (1) it lacks residual connections that may make backpropagation more complex and (2) it does not allow for the transformation learned in the AttentionPairBias to be fed in the ConditionedTransitionBlock at the same block. We found it to be beneficial to apply the following transformation order:

A key change between AlphaFold2 and AlphaFold3 was the non-equivariance of the denoising model of AlphaFold3 (compared to the equivariant IPA-based structure module of AlphaFold2) to rotations and translations. To encourage the robustness of the denoising model to such transformations their input is randomly translated and rotated before the denoising at training and inference times. To further reduce the variance of the denoising loss with respect to these variations, Abramson et al. [2024] use a rigid alignment between the predicted denoising coordinates and the true coordinates before computing the MSE loss.

However, we argue that on its own this procedure is theoretically problematic. One can define simple functions that would achieve zero rigid aligned MSE loss during training, but completely fail to sample realistic poses at inference time. For example, consider a model trying to fit a given structure with coordinates x. Let’s assume that for any noised structure within some reasonable noising perturbation (e.g. Δ=10σt), the model always predicts x: x^tdenoised=f(x^tnoisy,t)=f(x∗RT+T+ϵt,t)={xif‖ϵt‖<10σt,0otherwise.} where R and T are respectively a random rotation matrix and a random translation vector, ϵt and σt represent respectively the random noise and noise standard deviation for some diffusion time t. This model will have a loss approaching zero during training (one will never sample something beyond 10 standard deviations, and one could make this Δ arbitrarily large). However, when used at inference time, this model will consistently go out of distribution (and therefore predict a zero vector). This is because at low noise levels the interpolation between the current randomly rotated x^tnoisy and the predicted x^tdenoised may lead to a pose x^t−Δt that is very far from x and will fall beyond the 10σt mark. Figure 2 shows a graphical representation of this issue.

We overcome this issue by adding a rigid alignment with Kabsch algorithm after every step during the inference procedure before x^tnoisy and x^tdenoised are interpolated (see Figure 2 for a visual explanation). Informally, our diffusion interpolation operates on the minimal projection between noisy and denoised structures, guaranteeing, under the assumption of a Dirac distribution, that the interpolated structure is more similar to the denoised sample than the noisy structure. Empirically, we note that this change to the reverse diffusion has a bigger effect when training models on subsets of the full data where the model is more likely to overfit, on the other hand, the final Boltz-1 seems to largely denoising close to the projection making the Kapsch alignment not critical.

For the weighting of the diffusion loss we use (t^2+σdata2)∕(t^×σdata)2 in line with the EDM framework [Karras et al., 2022], rather than (t^2+σdata2)∕(t^×σdata)2 (AlphaFold3 Section 3.7.1 Eq. 6).

We noticed that, at a high level, the input-output composition of the confidence model is similar to that of the trunk. The trunk also takes as input its own final representations (through recycling) and outputs expressive representations used by the denoising model. Therefore, inspired by the way that researchers in the large language model community have been training reward models by fine-tuning the “trunk” of their pretrained generative models [Touvron et al., 2023], we define the architecture of our confidence model to contain all the components of the trunk and initialize its representation to the trained trunk weights. Hence, our confidence model presents an AtomAttentionEncoder, an MSAModule, and a PairFormerModule with 48 layers. In addition, we still integrate the predicted conformation as an encoding of the pairwise token distance matrix and decode the confidence with linear layers on the final PairFormer representation.

We feed to the confidence model not only the representations coming from the trunk but also a learned aggregation of the final token representation at each reverse diffusion step. These representations are aggregated through the reverse diffusion trajectory with a time-conditioned recurrent block and then fed concatenated to the trunk token-level features at the start of the confidence model. We further modify the way that token-level features are fed to the pairwise representations adding an element-wise multiplication of linearly transformed token-level features.

We detail our new full inference procedure in Algorithm 1 and provide a schematic representation in Figure 3. To train the confidence model we initialize all the components borrowed by the trunk to the final trunk weights (from the exponentially moving average) and initialize the weights of all the other components of the network randomly but with zeroed final layers not to perturb initial rich representation from the pretrained weights.

The AtomAttentionEncoder and AtomAttentionDecoder include a pair-biased transformer on the representations of every atom. In particular, the attention of these transformers is sequence-local: blocks of 32 atoms only attend to the 128 atoms that are closest to them in sequence space. We developed a GPU-efficient implementation of the sequence-local attention precomputing a mapping (performed in blocks of 16 tokens) to the key and query sequence embeddings for each 32 key tokens block. The attention is then performed in parallel in each 32x128 block achieving a block sparse attention with dense matrices.

At a high level the denoising model must be run repeatedly for every diffusion timestep for every separate sample we take, while the trunk can be run once and its representation fed to all those denoising model passes.

The most expensive components of the denoising model are represented by the computation of the attention pair bias for the token and atom transformers. However, by examining their computational graph, we find that these elements do not depend either on the particular input structure given to the denoising model or the diffusion timestep. In particular, these elements are: the attention bias of all the transformer layers in the AtomAttentionEncoder, AtomAttentionDecoder, and DiffusionTransformer, and the intermediate single and pairwise atom representations of the AtomAttentionEncoder. Therefore, we can also run these components once and share them across all the samples and the entirety of the reverse diffusion trajectory, significantly reducing the computational cost of the reverse diffusion at the cost of storing these representations and biases in memory.

During validation and confidence model training, the optimal alignment between the ground truth and predicted structure must be determined, accounting for permutations in the order of identical chains or symmetric atoms within those chains. Because the number of possible perturbations grows exponentially with the size of the complex, considering all of them is computationally unfeasible.

We devise the following procedure to perform an approximate, yet effective, atom matching. This operates in a hierarchical way searching (1) the optimal assignment of chains, and, then, (2) assuming chain assignment, to select atom perturbations greedily for every ligand or residue. For the first, for each symmetric chain, we compute the resulting global LDDT without changing any inner atom assignment. For the second step, iteratively for every ligand, amino acid, or nucleotide basis (one at a time), we find the perturbation of that ligand the most improves the global LDDT and greedily apply it.

Note that because the LDDT between pairs of elements that were not affected by the perturbation does not change, one can implement the test in the last step very efficiently only looking at the specific rows and columns of the distance matrix that change. In practice, we limit the number of perturbations of the chain assignment we consider to 100 and the perturbations of the atoms of each ligand to 1000.

To optimize memory efficiency in our model, we implement a chunking strategy that significantly reduces peak memory usage during inference. We follow the OpenFold chunking implementation for the Triangular Attention layer [Ahdritz et al., 2024], and extend it to the MSA Module, applying it at three critical points: the transition layers, pair-weighted average layers, and outer product layers. This improvement ensures the scalability of our model to larger inputs while maintaining a similar speed.

Triangle Self Attention, used in the PairFormer, suffers from O(n3) memory and time complexity. The memory complexity is often the limiting factor with regards to input size, for a given GPU. At moderate input sizes, it also dominates the runtime. A common solution to the memory issue is applying chunking to the calculation, which is typically done in PyTorch. We implement a Triton kernel that performs the calculation via a chunked online softmax. As such, the memory complexity is improved to O(n2). It also exploits the GPU architecture to speed up the computation for practical input sizes. This is an extension of FlashAttention that allows for the inner bias term [Dao et al., 2022]. A plot of the forwards runtime, compared to compiled PyTorch and another efficient kernel implementation [Song et al., 2023] can be found in Figure 4. The implementation can be found at https://github.com/latkins/trifast.

In the space of biomolecular structures, there have been other works using inference time potentials to guide the diffusion process. RFDiffusion [Watson et al., 2023] computes potentials based on the x0 prediction at each time step and applies a gradient update to encourage specific symmetric protein motifs and inter-chain contacts. Ishitani and Moriwaki [2025] also applies gradient updates to improve ligand structures using an RDKit conformer to define loss functions based on the RMSE between the bond lengths, bond angles, and chiral volumes of the predicted x0 conformer and reference conformer. By contrast, we use a flat-bottom potential based on the distance bounds, to enforce that the potential is within the range of realistic conformers without forcing it to match the RDKit conformer, expand to other physical properties and not only use gradient updates but also resampling. Finally, DecompDiff [Guan et al., 2024] also uses gradient updates in the reverse diffusion to improve the physical quality of generated molecule conformers.

For a chiral center Z with substituents A, B, C, D in decreasing Cahn-Ingold-Prelog (CIP) priority order, we say that Z has R chirality if the bonds (Z-A, Z-B, Z-C) form a right handed system and S chirality if they form a left handed system. To enforce that the predicted conformers have the correct chirality, we define potentials based on the improper torsion angles (X1, X2, X3, Z).

For a bond Z1=Z2 where Z1 has substituents A1, B1 and Z2 has substituents A2, B2 in decreasing CIP priority order, we say that Z1=Z2 has E stereochemistry if the higher priority atoms A1 and A2 are on opposite sides of the bond and Z stereochemistry otherwise. To enforce that the predicted conformers have the correct stereochemistry, we define potentials based on the torsion angles (A1, Z1, Z2, A2) and (B1, Z1, Z2, B2).

For planar double bonds C1=C2 between carbon atoms where C1 has substituents A1, B1, and C2 has substituents A2, B2, we define a flat bottom potential function to enforce planarity based on the improper torsion angles (A1, B1, C2, C1) and (A2, B2, C1, C2).

To ensure that the model generates ligand conformers with a physically realistic distance geometry, we define a flat-bottomed potential based on the bounds matrix which is generated by the RDKit package. For a ligand with N atoms, we define the lower and upper bounds matrices as L,U∈RN×N where for a pair of atoms (i, j), the lower and upper distance bounds are given by Li,j, and Ui,j respectively [Buttenschoen et al., 2024]: Egeom(x)=∑(i,j)∈Sbondsmax(‖xi−xj‖−1.2Uij,0)+max(0.8Lij−‖xi−xj‖,0)+∑(i,j)∈Sanglesmax(‖xi−xj‖−1.2Uij,0)+max(0.8Lij−‖xi−xj‖,0)+∑(i,j)∉Sbonds∪Sanglesmax(‖xi−xj‖−1.2Uij,0)+max(0.8Lij−‖xi−xj‖,0)

To prevent steric clashes, we constrain the distance between atoms in distinct and non-bonded chains to be greater than 0.725 times the sum of the atoms’ Van der Waals radii. Eclash(x)=∑(i,j)∈Scross chainsmax(0.725(ri+rj)−‖xi−xj‖,0) where the Van der Waals radius of atom i is denoted by ri

To prevent overlapping chains, we define a time dependent potential based on the distance between the centroids of symmetric chains with more than one atom. Eoverlapt(x)=∑(A,B)∈Ssymmetric chainsmax(bt−‖x¯A−x¯B‖,0) where x¯A is the centroid of chain A and bt is a time dependent parameter which controls the minimum distance between centroids and smoothly interpolates between 5.0 Å at t=1 and 1.0 Å at t=0 according to the schedule bt=1+4exp(−2(1−t))−1exp(−2)−1

To ensure that the model respects covalently bonded chains, we define a potential to enforce that covalently bonded atoms between separate chains are within 2Å.