Fifteen Ways to Fold a Protein: A 2026 Field Guide to Structure Prediction Foundation Models

Here is the sentence that should reorganize how you think about this entire field: the most accurate biomolecular structure predictor available, AlphaFold3, ships its model weights under a custom non-commercial license, and you cannot even download them. Academic and non-commercial researchers must request the parameters through a Google form, granted at DeepMind's sole discretion, with no redistribution permitted and outputs barred from training competing models.¹

That is not a footnote to the AlphaFold3 story. For anyone who has to ship something, it is the story.

The reversal is sharper when you look at where the field came from. In January 2022, DeepMind quietly relicensed the AlphaFold2 weights from non-commercial to CC BY 4.0, opening them to commercial use with attribution.² Two years later, when AlphaFold3 shipped, the weights went the other way: research-only, no redistribution, no commercial use.¹ One model relicensed up, into the open. Its successor relicensed down, behind a gate.

The protein structure prediction subfield now contains fifteen distinct foundation models.¹ Most surveys rank them by accuracy. That is the wrong first axis for a practitioner, because the accuracy leader is the one model a commercial team legally cannot deploy. The axis that actually constrains your work is the one almost nobody leads with: who is allowed to run the weights, for what, and at what cost. This guide leads with that.

Two ledgers

Keep two ledgers while reading any structure-prediction paper. The first records capability: what a model can demonstrably do on a benchmark its authors chose. The second records validity: whether the number survives a held-out test set, an honest baseline, and the failure modes you actually hit in production. The two diverge constantly. A model can post a state-of-the-art DockQ and still hand you a confidently wrong interface for the one complex you care about. AlphaFold3 tops the first ledger and, for a for-profit lab, fails the second on licensing alone.

The field splits cleanly into two technical lineages and one licensing fault line that cuts across both.

The lineages descend from two 2021 papers. AlphaFold2 introduced the Evoformer trunk, a stack of 48 attention blocks over a multiple-sequence-alignment representation and a residue-residue pair representation, feeding a structure module that emits 3D coordinates.² Weeks earlier the same year, RoseTTAFold introduced a "three-track" network that jointly processes 1D sequence, 2D residue-pair, and 3D coordinate information, with information flowing between all three tracks.³ Almost everything since is a descendant, an open reimplementation, or a single-sequence shortcut around the expensive MSA step.

The fault line is licensing. On one side sit the permissively licensed models you can put in a commercial pipeline today: AlphaFold2, AlphaFold-Multimer, ESMFold, OpenFold, Boltz-1, Boltz-2, Chai-1, Protenix, OmegaFold, RoseTTAFold2, RoseTTAFold All-Atom, RoseTTAFold2NA. On the other side sit the restricted ones: AlphaFold3 and HelixFold3, both non-commercial, plus the original RoseTTAFold v1 weights.¹⁴³ The capability frontier and the open frontier are not the same models, and the gap between them is where most of the practical decisions get made.

Five failure modes, before any benchmark

Before the models, the failure modes. These are the things that move a number from the capability ledger to the validity ledger, and every model below inherits some subset. Read the benchmark tables later with these in mind.

Overconfident wrong interfaces. AlphaFold-Multimer can produce confident but wrong interfaces and false-positive contacts.⁵ The confidence head is not a lie detector. A high ipTM on a protein-protein complex is evidence, not proof.

Hallucinated geometry. AlphaFold3 can produce confident-looking but spurious structures, including chirality and clashing-atom errors, and stochastic diffusion can yield hallucinations in unstructured regions.¹ Boltz-1 documents the same failure class: overlapping or stacked identical chains in large complexes, explicitly noted as shared with AlphaFold3.⁶

MSA-depth dependence. AlphaFold2 accuracy depends on MSA depth, and the model has limited accuracy for orphan sequences that lack deep alignments.² This is the recurring tax across the entire MSA-based family. A glowing benchmark on well-aligned targets tells you nothing about your orphan protein.

Disordered regions. AlphaFold2 has limited accuracy for intrinsically disordered regions, which land in the low-pLDDT bucket, and AlphaFold3 is also weaker there.²¹ If your biology lives in a disordered region, a low confidence score is telling you something true: do not trust the coordinates.

No ensembles. AlphaFold2 and AlphaFold3 predict mostly static single conformations, not conformational ensembles or dynamics.²¹ Boltz-2 is the partial exception, training on molecular-dynamics data toward ensembles, and even there the authors note it fails to capture large binding-induced conformational changes.⁷

The numbers in the tables below are real. So are these five.

The master table

Start with the map. Bold names link to the per-model notes further down.

Table 1: The 15 protein structure prediction foundation models. "Undisclosed" means the developers did not publish a parameter count, not that the model is small. Architecture, date, and license details per the model papers.^{125678941011123131415}

Two things jump out. First, parameter counts are mostly undisclosed. DeepMind never published a total for AlphaFold2 (the commonly cited ~93M is inferred from the released weights), AlphaFold-Multimer, or AlphaFold3.²⁵¹ The open reimplementations are more transparent: Protenix-v1 is 368M parameters and Protenix-v2 is 464M.¹² Second, the commercial-use column is binary and it does not track accuracy. The "No" rows are among the most capable models in the table.

Two eras: Evoformer, then diffusion

The cleanest way to organize fifteen models is by architecture generation, and there are two.

The Evoformer era runs from AlphaFold2 (2021) through its direct descendants. AlphaFold2 is an end-to-end network with two stages: the Evoformer trunk doing attention over an MSA representation and a pair representation with triangle attention for geometric consistency, feeding a structure module that produces 3D coordinates as per-residue rotations and translations.² It is not a transformer language model; it is a specialized geometric architecture, roughly 93M parameters across the released ensemble.² At CASP14 it reached median backbone accuracy around 0.96 Å RMSD and median domain GDT_TS of 92.4 out of 100, the result that ended the structure prediction problem as an open research question for most single-domain proteins.²

The diffusion era begins with AlphaFold3 in May 2024.¹ The architecture changed in two places. The Evoformer became a Pairformer with reduced reliance on MSA processing. The structure module was replaced by a diffusion module that predicts raw atom coordinates directly through a multiscale denoising process.¹ Instead of predicting residue frames and reconstructing atoms from them, AlphaFold3 denoises every atom directly, which is what lets a single model handle proteins, DNA, RNA, ligands, ions, and modified residues in one pass.¹

Figure 1: The two architecture eras. The diffusion era opens with AlphaFold3 and is immediately mirrored by open reimplementations because the original shipped with gated weights. Lineage and architecture per AlphaFold2,² AlphaFold3,¹ RoseTTAFold,³ ESMFold,⁹ Boltz-1,⁶ Chai-1,⁸ Protenix,¹² RoseTTAFold All-Atom,¹³ RoseTTAFold2NA.¹⁴

Why does this matter to a practitioner and not just an architecture historian? Because the diffusion models are the only ones that fold a protein, its nucleic-acid partners, and its bound ligand jointly, and because the open reimplementations are how you get that capability without AlphaFold3's licensing handcuffs. Everything downstream follows from that one shift.

The openness matrix, the part that actually decides things

This is the centerpiece. The license on the weights, not the code, is what governs your deployment. A model can publish Apache-2.0 source and still gate the weights, which is precisely what AlphaFold3 does.¹ License compliance here is not a single checkbox; it is a dependency graph. Read the weights license, then read the pipeline's bundled dependencies.

Table 2: Openness matrix, sorted by commercial usability. The headline license often lies about the deployable license. Per-model license terms from the model papers and repositories.^{125678941011123131415}

The traps matter. RoseTTAFold All-Atom ships a permissive BSD license on its own code and weights, but the default pipeline pulls in a PDB100 template database under CC BY-NC-SA and a SignalP6 dependency under academic terms, so a fully commercial deployment is not as simple as the headline license suggests.¹³ trRosetta is MIT at the network level, but the structure-building step depends on Rosetta/PyRosetta, which is free for academic use and requires a paid commercial license for for-profit work.¹⁵ HelixFold3's own documentation contradicts itself: the README says CC BY-NC-SA while the LICENSE file is a custom non-commercial license, and the discrepancy is unresolved.⁴ When the license is ambiguous, treat it as restrictive.

The cleanest commercial story belongs to the Boltz family: MIT on both code and weights, with no trap at the weights level.⁶⁷ Permissive code does not imply permissive weights, and permissive weights do not imply a permissive pipeline. Read all three.

Capability over time

Two charts frame the trajectory. The first shows when each family arrived; structure prediction went from a single 2020 method to a dense cluster of AlphaFold3-class models in 2024 and 2025.

Figure 2: Release timeline by family. Note the density of releases after May 2024, when the open reimplementations of AlphaFold3 arrived in quick succession. Dates from the model papers.^{1256789410111231415}

The second shows the parameter spread, which is wide and partly a fiction of disclosure. Where counts exist, they range from RoseTTAFold2NA at ~67M to ESMFold's ~15B total when paired with the ESM-2 15B language model.¹⁴⁹ Most AlphaFold3-class models simply do not report a number.

Figure 3: Disclosed parameter counts on a log scale. The gaps are the point: most diffusion-era models do not publish a total. Counts from the model papers and repositories.^29101214

A note on reading benchmarks: a benchmark number is a hypothesis about real-world performance, not a measurement of it. Several of the "beats AF3" claims below are self-reported by a model's own authors on their own test splits.¹² Treat them as directional.

The accuracy reference points

Here are the headline numbers that anchor the field, each on a different benchmark, which is itself a warning that cross-model comparison is harder than it looks. The metric and the test set stay attached to every claim, because a DockQ on 17 heterodimers and a DockQ on 541 recent-PDB structures⁶ are not the same claim.

Table 3: Headline benchmarks with metric and test set attached. This is a map of what each paper chose to report, not a leaderboard. Results per the model papers.^12567891014

The CASP14 GDT_TS of 92.4 is the one number in this whole field that earned its reputation under genuinely blind conditions; it approached experimental accuracy and was far ahead of every other group.² That is validity, not just capability. Everything after is about extending it to complexes, ligands, and nucleic acids, and about doing it under a license you can use.

Two readings of the rest of that table. First, the open AlphaFold3 reimplementations cluster around AlphaFold3, not above it, despite the marketing. Boltz-1's authors are careful: across protein-protein DockQ and protein-ligand metrics, the differences from AlphaFold3 and Chai-1 sit within 95% bootstrap confidence intervals, with AlphaFold3 holding a slight edge on overall mean lDDT attributed to its extra RNA/DNA distillation data.⁶ Read those claims as "competitive," not "decisively better." Second, the most sobering number is RoseTTAFold2NA's: across 224 monomeric protein-nucleic-acid complexes the mean lDDT is a respectable 0.73, but only about 29% of predictions reach lDDT above 0.8.¹⁴ Nucleic-acid complex prediction is still hard, and the confidence estimate is how you filter the usable predictions from the rest.

The models, by what you would actually use them for

Single-chain protein folding: AlphaFold2, ESMFold, OmegaFold, OpenFold

If you need a monomer structure and you have homologs, AlphaFold2 is still the open default. Its weights moved to CC BY 4.0 in January 2022, which permits commercial use with attribution, and the AlphaFold Protein Structure Database already holds more than 200 million precomputed structures, so for many targets you do not even run inference.² It is superseded for state-of-the-art by AlphaFold3 but remains the practical workhorse because AlphaFold3's weights are gated.²

OpenFold is the trainable, memory-efficient PyTorch reimplementation of AlphaFold2 from the AlQuraishi lab. It matches AF2 accuracy when trained from scratch, ships Apache-2.0 on code, weights, and training data, and exists precisely so you can retrain and fine-tune, which the original AF2 release does not support cleanly.¹¹ If you need to adapt the architecture rather than just call it, this is the one.

When you lack homologs, MSAs stop helping. ESMFold replaces the alignment step with embeddings from the ESM-2 protein language model (up to 48 layers, 15B parameters), folding directly from a single sequence.⁹ It is MIT-licensed, runs up to 60x faster than MSA-based predictors (a 384-residue protein in ~14.2s on a single V100), and produced the ESM Metagenomic Atlas of more than 617 million predicted structures, over 600 million of them computed in roughly two weeks on about 2000 GPUs.⁹ The accuracy trade is real: CAMEO TM-score ~0.83 versus ~0.88 for the full AF2 pipeline.⁹ You buy speed and orphan-protein coverage with a few points of accuracy. One trap: the ESMFold weights are MIT, but the successor ESM3 from EvolutionaryScale is non-commercial. Do not conflate them.⁹

OmegaFold is the other single-sequence option, pairing a ~670M-parameter language model (OmegaPLM) with a geometry-focused Geoformer.¹⁰ On antibodies it reported lower error than AlphaFold2 (RMSD 2.12 Å vs 2.98 Å, p=0.0017) and on orphan proteins a higher TM-score (0.73 vs 0.60, p=0.0238).¹⁰ It is Apache-2.0 and commercially usable. The honest caveat: the repository has been dormant since 2022, the preprint was never peer-reviewed, and the niche has largely been taken over by ESMFold.¹⁰ Treat it as a fast MSA-free baseline rather than a maintained tool.

Complexes and all-atom prediction: the AlphaFold3-class fight

This is where the licensing fault line bites hardest, because the accuracy reference and the deployable options diverge.

AlphaFold3 is the reference. It replaced the Evoformer with a Pairformer trunk feeding a diffusion module that predicts raw atom coordinates, and it handles proteins, DNA, RNA, ligands, ions, and modifications in one model.¹ DeepMind reports roughly 50% improvement over prior methods for protein interactions with other molecule types, with accuracy roughly doubled for some categories; a December 2024 Addendum later corrected some reported metrics, which is worth knowing if you cite the original numbers.¹¹⁶ And you almost certainly cannot use it. The weights are non-commercial, gated behind a discretionary request form, non-redistributable, and barred from training competing models; commercial structure prediction is handled internally by Isomorphic Labs.¹ Its real contribution to most teams is the architecture, which the open ecosystem promptly reimplemented.

Boltz-2 is the model most teams should reach for. It is an AlphaFold3-style architecture extended with a binding affinity module, MIT-licensed on code and weights, and as of mid-2026 the most widely adopted open AlphaFold3 alternative.⁷ I will give it its own section below, because affinity prediction is a genuinely different capability from structure.

Boltz-1, its predecessor, was the proof of concept: the first fully open, commercially usable model to approach AlphaFold3-level accuracy.⁶ On the recent-PDB test set its top-1 mean LDDT was ~0.716, with protein-protein and protein-ligand metrics on par with AlphaFold3 and Chai-1 inside the bootstrap confidence intervals.⁶ It shares AlphaFold3's failure class: hallucinated overlapping or stacked chains in large complexes, which the Boltz-1x variant's inference-time steering largely fixes.⁶ For most new work, go straight to Boltz-2.

Chai-1 from Chai Discovery is an AlphaFold3-like model with a twist: it adds a track of embeddings from a ~3B-parameter protein language model to enable strong single-sequence prediction.⁸ It edges AlphaFold3 on PoseBusters protein-ligand success (~77% vs ~76%) and exceeds AlphaFold-Multimer 2.3 on multimer DockQ (~69.8% vs ~67.7%), notably even in single-sequence mode.⁸ The licensing history is the cautionary tale: it launched in September 2024 under a restrictive non-commercial license and was relicensed to Apache-2.0 around late November 2024.⁸ The current weights are commercially usable; verify the LICENSE in the repo for the version you pull, because the history is not uniform.

Protenix, from ByteDance, is a full PyTorch reproduction of AlphaFold3, Apache-2.0 on both code and weights.¹² Protenix-v1 (368M) was described as the first fully open-source model to surpass AlphaFold3 across multiple benchmark sets, and v2 (464M) adds gains on antibody-antigen complexes.¹² That "surpass AF3" claim is self-reported on the developers' own benchmarks, so weight it accordingly, but the transparency is real: this is one of the few models in the field with a published parameter count.¹²

HelixFold3 from Baidu is another full AlphaFold3 reimplementation, this one in PaddlePaddle, and on some axes it is excellent: it surpasses AlphaFold3 on SAbDab antibody-antigen DockQ and reaches over 80% success with five specified epitope residues, with ligand success comparable to AlphaFold3.⁴ But the weights are non-commercial. The README claims CC BY-NC-SA while the actual LICENSE file is a custom non-commercial license, and the contradiction is unresolved.⁴ Capable, restricted, and ambiguously documented; for commercial work, skip it.

Protein-nucleic-acid and mixed assemblies: the RoseTTAFold lineage

The Baker lab's three-track architecture is the other root of the field, and its descendants specialize.

RoseTTAFold (the original, Science 2021) approached AlphaFold2-level accuracy on CASP14 while being far cheaper, and folds a single structure in roughly ten minutes on a gaming PC.³ The licensing is version-dependent, and this is the trap: the original v1 trained weights are under the non-commercial Rosetta-DL license, while RoseTTAFold2 (MIT) and RoseTTAFold All-Atom (BSD) are permissive.³ If you cite "RoseTTAFold is open," specify the version.

RoseTTAFold All-Atom introduced an atom-bond graph representation that treats ligands, ions, and modifications as flexible atoms and bonds rather than residue templates, enabling covalent modifications and mixed assemblies.¹³ On the CAMEO blind docking benchmark it outperforms classical docking like AutoDock Vina while preserving correct bond lengths, ring planarity, and chirality.¹³ The model code and weights are BSD, but as the openness matrix shows, the default pipeline drags in non-commercial template data and an academically-licensed dependency.¹³

RoseTTAFold2NA is the focused, lightweight choice for protein-nucleic-acid complexes: ~67M parameters, pure MIT, no weights-level trap.¹⁴ It was trained on a deliberately small set, about 26,128 protein clusters, 1,632 RNA clusters, and 1,556 protein-nucleic-acid complex clusters, and on a 14-case held-out test it correctly identified 13/14 complexes against 1/14 for AlphaFold-plus-docking baselines.¹⁴ Be honest about its ceiling, though: only ~29 to 30% of its complex predictions reach lDDT above 0.8, so the confidence estimate is not optional, it is how you filter usable models from the rest.¹⁴

The historical baseline: trRosetta

trRosetta (2020) predates the end-to-end era. It is a 2D dilated ResNet that predicts inter-residue distances and orientations, then hands those restraints to Rosetta energy minimization.¹⁵ It substantially outperformed the prior leading methods on CASP13 and CAMEO in 2019 and 2020.¹⁵ It is foundational and historical now, superseded by RoseTTAFold and AlphaFold2, and its full pipeline carries the Rosetta commercial-license gate.¹⁵ Use it to understand the lineage, not to fold proteins in 2026.

Boltz-2: structure plus affinity

Boltz-2 deserves its own section because it does something the others do not. It is an AlphaFold3-style diffusion structure model extended with an affinity module that predicts protein-small-molecule binding, both binary binder classification and continuous regression.⁷ The reported result should make a drug-discovery team pay attention: it is described as the first AI model to approach free-energy perturbation (FEP) accuracy while being at least 1000x cheaper.⁷ On the CASP16 affinity challenge of 140 protein-ligand pairs it outperformed all participants out of the box, on a FEP+ four-target subset it reached Pearson R ~0.66, and for hit discovery it reports an enrichment factor of 18.4 at 0.5% on MF-PCBA.⁷ If your question is "will this compound bind, and how tightly," Boltz-2 is the only model in this survey that answers it directly.⁷

Keep the validity ledger open here too. Boltz-2's structure accuracy is modestly behind AlphaFold3 on the hardest complexes and antibody-antigen cases, the authors say so plainly.⁷ Affinity performance varies widely across assay types and protein families, weaker on GPCRs for instance, and the authors say the applicability domain needs further study.⁷ It also fails to capture large binding-induced conformational changes.⁷ None of that diminishes the achievement; it bounds it. As of mid-2026 it is the leading openly-licensed AlphaFold3 alternative with affinity prediction, with no successor announced.⁷

A decision procedure

Strip away the leaderboards and the choice is mostly mechanical.

Figure 4: A task-and-license decision tree. The license branch is decisive for anyone shipping a product. Per-model licenses from Table 2.^{12567841112314}

In prose, the same logic:

Single-chain protein, homologs available, fully open: AlphaFold2, or check the AlphaFold DB first since your structure may already be computed.² Need to retrain or fine-tune? OpenFold.¹¹

Single-chain protein, orphan or antibody, or you need speed at scale: ESMFold (MIT, fastest, metagenome-scale).⁹ OmegaFold if you specifically want its antibody numbers and accept an unmaintained repo.¹⁰

Complexes, ligands, DNA/RNA, and you can ship commercially: Boltz-2 for structure plus affinity, Chai-1 or Protenix as alternatives. All three are permissively licensed.⁷⁸¹²

Protein-nucleic-acid complexes specifically, lightweight and MIT: RoseTTAFold2NA, with the confidence filter applied.¹⁴

Non-commercial research only, want the accuracy ceiling: AlphaFold3, via the gated request form and the free AlphaFold Server for small jobs.¹

Need binding affinity, not just structure: Boltz-2 is currently the only open model in this table that predicts it.⁷

What is not known, stated plainly

The honest gaps are large enough to change decisions.

Parameter counts are mostly undisclosed. AlphaFold2's ~93M is inferred, not published; AlphaFold-Multimer, AlphaFold3, Boltz-1, Boltz-2, Chai-1's total, and the entire RoseTTAFold family report no figure.^2516783 This is not a minor omission; it makes inference-cost and hardware planning a matter of measurement rather than reading a spec sheet.

Benchmark superiority claims over AlphaFold3 are frequently self-reported. Protenix's "first to surpass AF3" and several HelixFold3 wins come from the developers' own evaluations on their own splits.¹²⁴ Independent, held-out evaluation against an honest baseline is the standard the field has not uniformly met. Always beat a trivial baseline first, and trust independent reproductions over author claims.

Training-data composition is partially disclosed at best, and cutoffs are getting stale. AlphaFold3, Chai-1, HelixFold3, and RoseTTAFold All-Atom all describe their data only partially.¹⁸⁴¹³ Cutoffs also differ in ways that affect fair comparison: AlphaFold3, Boltz-1, and HelixFold3 train to a 2021-09-30 PDB cutoff, while Boltz-2 trains to 2023-06-01, so a like-for-like comparison has to control for what each model could have seen.¹⁶⁴⁷ When you cannot see the training set, you cannot fully reason about leakage into a test set.

License documentation is sometimes self-contradictory. HelixFold3's README and LICENSE disagree.⁴ RoseTTAFold's licensing varies by version in ways that headlines flatten.³ Permissive code does not imply permissive weights, and permissive weights do not imply a permissive pipeline. Read all three.

The bottom line

The field's center of gravity has moved. The capability frontier is the gated AlphaFold3, but the deployment frontier is a cluster of open AlphaFold3 reimplementations, Boltz, Chai, and Protenix, that reproduce the architecture without the lock.¹⁶⁷⁸¹² For a practitioner, that is the good news buried under the licensing problem: the most useful models in this table are also the ones you are allowed to run.

Three things you can act on today. Use the open AlphaFold3 reproductions as your default for commercial all-atom work, with Boltz-2 for structure plus affinity.⁷ Match the model to the MSA you actually have, AlphaFold2 with deep alignments, ESMFold without.²⁹ And treat every confidence score as a hypothesis, because AlphaFold-Multimer's confident wrong interfaces, AlphaFold3's and Boltz-1's stacked-chain hallucinations, and RoseTTAFold2NA's roughly 70% of complexes below the lDDT 0.8 line are not edge cases, they are the working conditions.⁵¹⁶¹⁴

Pick by task and license first. Read the LICENSE file rather than the README. Let the benchmarks break ties. The model that wins your benchmark is not always the model you are allowed to ship.

References