acceptodds
Under review as a conference paper at ICLR 2027

SimpleFold2: Efficient Biomolecular Co-folding with Transformers

10 views

Abstract

Biomolecular co-folding models jointly predict the 3D atomic structure of systems where a protein interacts with other proteins, ligands, and nucleic acids. Most modern co-folding models build on the AlphaFold lineage, which designed bespoke architectures like pair representations, triangle updates, and deep MSA encodings. In this work, we ask if co-folding models require these domain specific designs or could instead be framed as general purpose generative models from the ground up. We introduce SimpleFold2, a flow matching model for co-folding built exclusively using general purpose transformers. Similar to text-to-image models, we use pre-trained protein language models (pLMs) to embed sequence information, and we do not incorporate triangle updates, template stacks, recycling, or equivariant modules. Because every layer in SimpleFold2 is ordinary attention or an MLP, it inherits the favorable behavior of modern transformers. We scale SimpleFold2 to 3B parameters and demonstrate strong performance on protein-ligand co-folding and competitive performance on monomers. We then show how the efficiency of SimpleFold2 leads to strong test-time scaling behavior. Overall, SimpleFold2's architecture ensures it is highly efficient on modern hardware: it uses the memory of AlphaFold-style models, runs faster for -residue complexes, and can even fold a -residue complex on a single NVIDIA H100 GPU in 39s using only 62 GB of memory, a task well beyond most comparable methods.

Primary area:
applications to physical sciences (physics, chemistry, biology, etc.)
Keywords:
Generative Models, Protein Folding

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 5 reviews, above 85% of the others.
Reviewer_ZU2zOpenReview ↗
Rating
4
Confidence
2
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

At its core, SimpleFold2 treats biomolecular co-folding like a standard generative task. Instead of relying on the heavy, highly specialized machinery of AlphaFold (like those notoriously slow O(L3)O(L^3) triangular updates or deep MSA stacks), it strips everything back to a general-purpose O(L2)O(L^2) transformer.

By fusing pre-trained language models in an encoder-decoder setup, it gets the evolutionary context it needs without the computational bloat. They scaled this brute-force, simple architecture up to 3.3 billion parameters, and the payoff is massive: it folds huge 5,000-residue complexes on a single GPU up to 10x faster than AF3-style models, using just a fraction of the memory.

Overall, I think this is a work with substantial innovation.

Critical strengths
  • Speed and Memory: It’s incredibly fast and lean. Running ~10x faster with roughly 70% less memory makes it genuinely viable for massive high-throughput screening and agent-driven workflows.
  • No More Size Limits: Getting rid of cubic scaling means the traditional memory bottleneck is gone. Folding nearly 5,000 residues on a single H100 in under a minute is a huge practical win.
  • Unseen Ligand Prediction: It punches way above its weight on novel protein-ligand pockets, matching or beating heavily specialized open-source models on data it hasn't seen before.
  • Test-Time Scaling: Because a single run is so computationally cheap, you can just throw compute at it, sample a ton of structural candidates, and easily hit a new Pareto frontier for time-vs-accuracy.
Critical weaknesses
  • Brute-Force Parameter Cost: It takes 3.3 billion parameters to do what AlphaFold-style models accomplish with a few hundred million. It's fast at inference, but it's fundamentally less parameter-efficient.
  • Data Hungry: If the public PDB doesn't have a massive amount of training data for a specific interaction (like antibody-antigen or protein-RNA), this model struggles more than the state-of-the-art baselines.
  • Lower Single-Shot Accuracy: Its "first guess" isn't always as accurate as highly specialized models, particularly for protein-protein interactions. It relies heavily on its blazing speed to generate multiple samples and pick the best one.
  • Missing Historical Context (Literature): While the paper extensively cites the latest 2024/2025 AF3 derivatives, it misses the foundational works that actually paved the way for this "pLM-only, simplified" philosophy. The authors should cite OmegaFold and the original ESMFold to acknowledge the pioneers of MSA-free folding. Additionally, referencing early generative deep learning models for protein-ligand docking (like DiffDock) would provide a more complete historical context for their impressive ligand results.
  • Open-Source Availability: The claims about efficiency and speed are phenomenal, but currently, the paper is under double-blind review and lacks a code repository. The community can only verify and build upon this if the code and model weights are released. I strongly encourage the authors to fully open-source their codebase and the 3.3B model weights upon publication.
Questions for authors

Nothing

1 comment
AuthorsOpenReview ↗

Official Comment from Authors to Reviewer ZU2z

Thank you for your positive review and your helpful suggestions.

Q1. Parameter count.

  • We agree that SimpleFold2 has more parameters than AlphaFold-style models including AlphaFold3, OpenFold3 and ESMFold2. However, since its generator uses no pair representation or triangle updates, these parameters sit in dense attention and MLP layers that run efficiently on GPUs and whose cost grows roughly linearly with sequence length. Sampling a single seed in SimpleFold2 therefore takes 4.3 s, against 42.8 s for OpenFold3-p2 and 15.7 s for ESMFold2 (general response #3), and the gap widens for larger complexes. Its memory cost also grows roughly linearly, so it samples the 4,960-token example in Fig. 1a on one H100 in 42 s per sample, using 46 GB of GPU memory including the frozen language models. Since these dense layers are standard implementations, one future direction to scale up the model size while keeping the compute FLOPs manageable is to apply sparse models like Mixture of Experts (MoEs). At benchmark sizes, it performs more matmul FLOPs per seed than the baselines (1.2 versus 0.7–0.9 PFLOP), but these dense operations run far more efficiently on GPUs than triangle updates. Its training also took less compute, about 3.6 × 10^21 FLOPs against an estimated 8.0 × 10^21 for OpenFold3-p2 and 7.5 × 10^21 for ESMFold2 (Appendix L; see our reply to Reviewer 8zHw).

Q2. Data requirements and single-shot accuracy.

  • We agree that SimpleFold2 may fall behind on categories where training data is sparse like antibody-antigen. However, it should be noted that AlphaFold-style models build strong structural priors into their architectures, most notably pair representations updated by triangle operations, and such priors help most where training examples are few, as for antibody–antigen and protein–RNA interfaces. SimpleFold2 removes most of these priors from its generator and learns this geometry from data, so it is competitive where data are plentiful, such as protein monomers and protein–ligand complexes. In these categories it performs well: on FoldBench, its protein monomer lDDT (0.83) is comparable to the baselines and its protein–ligand success is ahead of Chai-1, and on the OpenBind ligand benchmark it reaches 39.3% success-valid, ahead of OpenFold3-p2 (35.5%) and AlphaFold3 (25.8%).

Q3. Additional related work.

  • Thank you for the suggestions. We have added OmegaFold and DiffDock to the related work, and moved the discussion of the original ESMFold from Appendix A into the main related-work section (Section 2).

Q4. Code and weights release.

  • We appreciate the reviewer for bringing this up. We are planning to release the codebase and checkpoint for SimpleFold2 model once the paper is accepted.
Reviewer_BydyOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents SimpleFold2, extending SimpleFold (ICLR 2026) from protein monomer folding to general biomolecular co-folding, including protein–protein, protein–ligand, and protein–nucleic acid interactions. The model adopts an encoder–decoder architecture, combines pretrained representations from ESMC-6B and E1-600M, and introduces modality-specific featurization while retaining a general-purpose Transformer and flow-matching framework.

Experiments on Runs N' Poses, FoldBench, and OpenBind demonstrate competitive performance, particularly for protein–ligand complexes, together with substantial improvements in inference speed and memory efficiency over AlphaFold-style architectures.

Critical strengths

1.By eliminating explicit pair representations and triangle operations from the generative trunk, SimpleFold2 substantially reduces inference time and memory consumption. These improvements are particularly valuable for large biomolecular complexes and high-throughput structure prediction.

2.Extending a general-purpose Transformer framework to biomolecular co-folding is practically important. The reported results on Runs N' Poses and OpenBind are encouraging, particularly for protein–ligand prediction and binding pockets with low similarity to the training data.

Critical weaknesses

1.SimpleFold2 builds substantially on the Transformer and flow-matching framework established by SimpleFold. Although it introduces an encoder–decoder separation and modality-specific representations, the paper does not sufficiently establish which modifications are essential for co-folding. In particular, controlled ablations isolating the contributions of these architectural changes are limited, making it difficult to assess the independent methodological novelty beyond extending SimpleFold to additional molecular modalities.

2.Although Table 2(a) shows that E1 + ESMC fusion improves monomer prediction, Figure 7 indicates that ESMC-only representations perform better on several co-folding tasks, including protein–ligand, protein–DNA, and protein–RNA prediction. Moreover, the encoder-fusion ablations are conducted only at the 400M scale. Without further controlled comparisons, it remains unclear whether fusion is beneficial for the final 3.3B model and how much of the reported performance depends on the choice of pretrained protein representations.

Questions for authors

1.Beyond extending SimpleFold to additional molecular modalities, which architectural modifications are essential for achieving competitive co-folding performance? In particular, could the authors provide evidence isolating the contributions of the encoder–decoder separation and modality-specific representations? This would help clarify the methodological insights established by SimpleFold2 beyond the original Transformer and flow-matching framework.

2.Figure 7 shows that ESMC-only representations outperform E1 + ESMC fusion on several co-folding tasks. What motivates the selection of fusion as the default configuration? Does this choice remain beneficial at the final 3.3B scale? Additionally, while the paper reports negligible differences in FLOPs, does this account for the end-to-end computational and memory costs of running both pretrained encoders?

More importantly, could the authors provide a controlled comparison in which SimpleFold2 uses ESM2-3B, the pretrained protein encoder employed by the original SimpleFold, while keeping the architecture and training setup otherwise unchanged? This would help disentangle the contributions of the proposed co-folding framework from those of the pretrained representations and better establish the independent value of SimpleFold2.

3 comments
AuthorsOpenReview ↗

Official Comment from Authors to Reviewer Bydy

Thank you for your review. We have run new controlled comparisons for the language-model encoders and the positional encodings.

Q1. Controlled ablations of the architectural changes.

  • Following the valuable suggestion, we ran controlled studies of the encoders and the positional encoding at 411M parameters. Each arm keeps the code, data order and 100k-step schedule of the baseline and changes a single component, and all arms are evaluated with 25 samples per target.
411M model at 100k stepsProtein–protein success (%)Protein–ligand success (%)Protein–DNA success (%)Protein monomer lDDTRuns N' Poses success, mean over bins (%)
Baseline: ESMC-6B + E1-600M, axial RoPE44.734.364.80.79637.5
ESMC-6B only42.532.261.30.77036.7
ESM2-3B only (the encoder of SimpleFold)29.928.356.70.73433.4
Absolute positional encoding instead of RoPE46.032.665.80.79435.7
  • We chose to fuse ESMC-6B and E1-600M because fusion improved monomer accuracy at 400M. Without E1 and its MSA, the model is worse on every FoldBench interface category, significantly on protein–ligand (2.1 points) and protein–DNA (3.5 points), and on protein monomers (0.026 lDDT), while Runs N' Poses is unchanged; only the small nucleic-acid monomer sets favor ESMC-6B alone. Fig. 7 was based on single-sample evaluation; we have added these results to the revised paper (Section 4.6, Appendices K.1–K.2 and Table 9), and the caption of Fig. 7 now notes that it uses single-sample evaluation.

  • With ESM2-3B (the encoder used by SimpleFold) as the only encoder, the model generally performs worse , including 14.8 point drop on protein–protein, 16.9 points on protein–peptide, 6.0 points on protein–ligand and 0.062 monomer lDDT, and the gap does not close with training. This is intuitive, stronger sequence embedder help structure prediction in the same way that stronger LLMs help text-to-image generation. Our contribution in this paper is to show that the SimpleFold philosophy can be applied to the more general co-folding setting, which was still an open question. Since ESMFold2 uses the same ESMC-6B, so our comparisons with ESMFold2 hold the main language model fixed.

  • Replacing axial RoPE with absolute positional encodings leaves interface success rates and monomer folding unchanged, but it significantly lowers ligand docking on Runs N' Poses (by 1.8 points) and interface lDDT on protein–DNA, protein–RNA and protein–peptide (by 0.03–0.04). These additional experiments further validate the design choices adopted in SimpleFold2 and we have updated the paper to include these additional experiments (Section 4.6 and Appendix K).

Q2. Cost of running two encoders.

  • The statement about negligible FLOPs in the caption of Fig. 7 referred only to the folding model, and we have further clarified it in the revised paper (Fig. 7 caption and Appendices I and K.1). In particular, end to end, the two encoders take 0.24 s and about 10 TFLOP per seed, under 6% of the time and under 1% of the FLOPs of a 4.3 s SimpleFold2 seed (general response #3). E1-600M, which reads eight MSA rows per chain, accounts for a little under half of these FLOPs, so fusion about doubles the language-model compute of ESMC-6B alone while remaining a small part of the total. The two encoders hold 28.4 GB of fp32 weights, of which E1-600M accounts for 2.4 GB. With them, a prediction on one H100 peaks at 28.7–41.2 GB across the sizes in Fig. 1e, against 6.9–9.9 GB for the sampler alone, and every size still fits on one 80 GB GPU.

Thanks for the rebuttal. Most of my concerns are solved. I am therefore willing to raise my score.

AuthorsOpenReview ↗

Official Comment from Authors

We thank the reviewer for raising the score and acknowledging our contributions.

Reviewer_CGWbOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
3
Read review
Paper summary

SimpleFold2 extends a transformer-based flow-matching approach to biomolecular co-folding of proteins, nucleic acids, and ligands. It combines ESMC and E1 representations, including shallow MSA information, with a sequence encoder and an all-atom flow decoder. The generative backbone avoids explicit pair representations and triangular updates. Evaluation on Runs N’ Poses, FoldBench, and OpenBind shows competitive protein–ligand performance and substantial reported inference speedups, alongside weaker results on several other co-folding tasks.

Critical strengths
  1. A simpler generative architecture with meaningful empirical support. The work demonstrates that a transformer-based generative backbone can support diverse biomolecular inputs while remaining competitive on protein–ligand co-folding. Its 68.1% ranked success rate on Runs N’ Poses is close to AlphaFold3’s 69.7%, providing substantive evidence for the architectural approach.

  2. Potential computational benefits. Under the evaluated configurations, SimpleFold2 reports substantially faster inference, including 3.6 versus 15.0 GPU-seconds per seed for ESMFold2 on Runs N’ Poses. Its demonstrations on large assemblies also suggest practical value for applications constrained by computational resources.

Critical weaknesses
  1. The practical accuracy–efficiency advantage remains insufficiently established. Despite using shallow MSAs, SimpleFold2 trails single-sequence ESMFold2 on eight of nine FoldBench categories in ranked performance, including all six interface tasks. This substantially limits its demonstrated competitiveness as a general co-folding method. The efficiency comparison fixes ESMFold2 at ten trunk loops, without testing reduced-loop configurations. Consequently, it remains unclear whether SimpleFold2 offers a favorable accuracy–runtime tradeoff against a faster ESMFold2 configuration.

  2. Training-data specification and test independence are insufficiently documented. The paper identifies PDB structures and OpenFold3 distillation data and provides sampling proportions, but does not clearly specify dataset sizes, versions, PDB cutoff dates, or filtering and test-exclusion procedures. These omissions make reproducibility and independence from the evaluation benchmarks difficult to assess, weakening confidence in the generalization claims.

Questions for authors

Have you explored additional trunk refinement passes for SimpleFold2? Could you also evaluate ESMFold2 with a single trunk loop on FoldBench and compare both prediction accuracy and inference speed under matched hardware and sampling settings? This would clarify whether SimpleFold2’s efficiency advantage persists against a faster ESMFold2 configuration.

1 comment
AuthorsOpenReview ↗

Official Comment from Authors to Reviewer CGWb

Thank you for your review and for the concrete experiment you suggested, which we have now run.

Q1. Accuracy–efficiency tradeoff against a faster ESMFold2 with fewer trunk passes.

  • As suggested, we evaluated ESMFold2 on FoldBench and Runs N' Poses with 0, 1, 3, 5, 10 and 20 recycling loops, using 25 samples per target on the same hardware; ten loops is the setting used in the ESMFold2 paper. Table 8 in Appendix I of the revised paper lists 0, 1, 5 and 10 loops. The table below lists the main configurations together with ESMFold2 without its MSA, as in our reply to Reviewer PnAh (Q4). Accuracy is the average over 25 samples per target.
SettingCost per seed (H100-s)Protein–protein success (%)Protein monomer lDDTRuns N' Poses success (%)
ESMFold2 (default, 10 loops)15.773.00.88465.1
ESMFold2, 1 loop9.871.40.87160.3
ESMFold2, no loop9.265.30.85452.3
ESMFold2, no MSA14.365.10.84364.7
SimpleFold2-3B (default)4.356.00.82564.2
SimpleFold2-3B, no MSA4.352.90.80664.8
  • SimpleFold2 remains more efficient than ESMFold2 even in ESMFold2's fastest configurations: with one loop or a single trunk pass, ESMFold2 still needs 9.8 s and 9.2 s per seed, more than twice the 4.3 s of a SimpleFold2 seed with its confidence module, and 14.3 s without its MSA. These configurations also cost ESMFold2 accuracy. With a single pass, it loses 7.7 points of protein–protein success, 0.030 monomer lDDT, 12.3 points on protein–ligand and 28.0 points on antibody–antigen, and its Runs N' Poses success drops from 65.1% to 52.3%, well below SimpleFold2's 64.2%. We agree that SimpleFold2 is less accurate per sample on protein–protein and protein monomers. ESMFold2 is more accurate on protein monomers, protein–protein and protein–ligand, while the differences on antibody–antigen, protein–peptide, protein–DNA and protein–RNA are not significant. At benchmark sizes, our advantage is much higher inference throughput rather than higher per-sample accuracy; general response #2 and Appendix J show how this plays out at equal GPU time. Fewer loops also do not shrink ESMFold2's pair representation, whose memory grows quadratically with sequence length, whereas SimpleFold2's activation memory grows roughly linearly.

  • As for additional trunk passes in SimpleFold2, which would resemble recycling in AlphaFold3 and recent looped transformers: SimpleFold2 is not trained with a looped encoding trunk, so adding passes only at inference is unlikely to improve its accuracy. Since its encoder takes only 0.01 s per seed (general response #3), extra passes would add little cost, and we see training with looped passes as a promising direction for future work.

Q2. Training and test data specification.

  • We follow exactly the same PDB data cutoff as main co-folding models like AlphaFold3, OpenFold3, ESMFold2. Namely only PDB structures released before September 30, 2021 are included in training data, which makes the results comparable to other baseline models.

  • For Runs N' Poses, we filter the protein-ligand systems to include pairs on which the original Runs N' Poses authors compare different models including AlphaFold3, Protenix, Chai-1 and Boltz-1. We further follow OpenFold3-p2 and only keep the systems that are also reported in its main figure, which eventually leaves 1,739 protein-ligand pairs in 1,544 systems. Lastly, we remove four pairs that OpenStructure could not score in some runs, which leaves 1,735 pairs in 1,541 systems. All results regarding Runs N' Poses in this work are reported in the same shared target list for fair comparison. For OpenBind, we follow the official set which does not contain targets released before the cutoff date. We take the OpenBind baseline results from the official report, and Appendix H of the revised paper lists the source of every baseline number.

Reviewer_PnAhOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents SimpleFold2, a biomolecular co-folding model built only from standard transformer blocks.

On accuracy:

  • Runs N’ Poses: 68.1% ranked success, about 1.6 points below AF3 and slightly above ESMFold2. Oracle success matches AF3 at 77.7%, and the low-similarity bins also roughly match AF3.
  • OpenBind: 39.3% success-valid, ahead of AF3 and OpenFold3-p2.
  • FoldBench: Competitive on monomers, protein–ligand, protein–peptide and protein–DNA. Clearly behind on antibody–antigen and protein–RNA.

On efficiency, the paper claims about 10× lower memory and wall-clock than OpenFold3-p2/ESMFold2 at around 1,700 residues, folding of complexes up to about 44k tokens on a single B200, and a better oracle success vs. GPU-time frontier under test-time scaling.

Critical strengths
  1. Competitive protein–ligand accuracy without pair or triangle machinery.
  2. Large practical efficiency gains. Per-seed cost is 3.6 s vs. 35.2 s for OpenFold3-p2 on RnP, memory scales roughly quadratically, and complexes of tens of thousands of tokens run on one GPU.
Critical weaknesses
  • No training cutoff: The paper never states the PDB release-date cutoff, or any deduplication against Runs N’ Poses, FoldBench or OpenBind. OpenBind was released in 2026, so this matters. Without it, the headline benchmark comparisons cannot be trusted.

  • Ranking depends on a triangle module: The “ranked” numbers rely on a confidence module that does build a pair representation with triangle multiplicative updates (§3.1). That contradicts the “no triangle updates” framing and Table 1’s O(L²) characterization. It is also unclear whether this module’s cost is included in the reported runtime and memory, for example for the 4,960-residue and 44k-token cases.

  • Test-time scaling is oracle best-of-k: All of the scaling results (Fig. 1b, Fig. 5b–c, Fig. 16) report oracle success, which is not achievable in a real pipeline. The practical claim needs confidence-ranked curves.

  • Appendix G contradicts the framing. There, SimpleFold2 is below ESMFold2 at every matched budget on antibody–antigen and protein–ligand. This undercuts the claim to “set new Pareto boundaries” and the statement that efficiency “often compensates.”

  • Unequal settings: OpenFold3-p2 runs in fp32 with 10 recycles and full MSA caps. SimpleFold2 runs in bf16 with torch.compile and MSA depth 8. Optimized triangle kernels such as cuEquivariance are not used for the baselines.

  • Unclear accounting: It is not stated whether MSA search time or the ESMC-6B/E1 embedding passes are counted. The “AlphaFold-style” memory claims rest on only two baselines.

  • Fig. 15 bottom row: The predictions for 1LP3, 9C3J and 6HTX are visibly incorrect: collapsed blobs vs. symmetric capsids. Yet the text cites Fig. 15 as evidence of large-assembly capability. The paper reports no accuracy (e.g., TM-score) for these cases beyond the single 8RUC example. As written, the “folds a 44k-token complex” framing amounts to “runs without OOM,” not “predicts correctly.”

Questions for authors

What is the training-data cutoff date, and what filtering was applied against each evaluation benchmark? Are any OpenBind or RnP targets present in your training PDB set? Is the confidence module, with its pair representation and triangle updates, included in the wall-clock and memory numbers in Fig. 1d–e and Fig. 15? What are its cost and scaling at 5k and 40k tokens? Can you show test-time scaling with confidence-ranked selection rather than oracle best-of-k, at least for RnP? How do the speed and memory comparisons change if OpenFold3-p2 runs in bf16 with optimized triangle kernels and a comparably shallow MSA? Do the timings include MSA search and pLM embedding? What are the TM-score or DockQ values for the Fig. 15 assemblies? Do you consider the bottom-row predictions successful? Where is the promised in-depth evaluation of the PDB-only model? How does it perform on RnP, given the claim that results are not due to distillation from AlphaFold-style models?

4 comments
AuthorsOpenReview ↗

Official Comment from Authors to Reviewer PnAh

Thank you for your careful review and your precise questions. We answer each of them below and refer to the general response where a point is shared with other reviewers.

Q1. Training cutoff and benchmark leakage risk.

  • We follow exactly the same PDB data cutoff as main co-folding models like AlphaFold3, OpenFold3, ESMFold2. Namely only PDB structures released before September 30, 2021 are included in training data, which makes the results comparable to other baseline models.

  • For Runs N' Poses, we filter the protein-ligand systems to include pairs on which the original Runs N' Poses authors compare different models including AlphaFold3, Protenix, Chai-1 and Boltz-1. We further follow OpenFold3-p2 and only keep the systems that are also reported in its main figure. All results regarding Runs N' Poses in this work are reported in the same shared target list for fair comparison. For FoldBench and OpenBind, we follow the official set which does not contain targets released before the cutoff date. We take the OpenBind baseline results from the official report, and Appendix H of the revised paper lists the source of every baseline number. More details can be found in #1 of the General response.

Q2. Triangle updates in the confidence module.

  • We thank the reviewer for pointing this out. We have revised the draft to restrict the claim of no triangle updates to the structure generator (abstract and introduction), and Table 1 now lists the confidence module with its O(L³) scaling. The confidence module uses triangle multiplication but no triangle attention, in four blocks on a 64-channel pair representation, and it scores each sample once, whereas OpenFold3-p2 and ESMFold2 run 48 pair-updating blocks in each of their 11 trunk passes. Even with the confidence module included, a SimpleFold2 seed costs 4.3 s, about 10× less than OpenFold3-p2 and 3.6× less than ESMFold2 at their default settings, and general response #3 breaks this cost down by component.

  • The confidence module is not included in the runtime and memory of Figs. 1d–e and 15. At benchmark sizes, it adds 0.6 s per seed. Its activation memory grows with the square of the token count, by about 2.65 GB per (1,000 tokens)², so on one H100 it fits up to about 3.2k tokens as deployed, or 4.5k with the language models moved off the GPU, and it takes 0.9 s per structure at 3k tokens. On a B200, it fits up to 7–8k tokens and takes 1.8 s per structure at 5k tokens, which covers the 4,960-token example in Fig. 1a. At the 44k tokens of Fig. 15, a single 64-channel pair tensor would take 247 GB, so the module cannot run on one GPU without cropping. Appendix I of the revised paper now reports these numbers.

Q3. Ranked test-time scaling.

  • Appendix J of the revised paper (Figs. 17 and 18) now reports oracle and confidence-ranked success against GPU time per target, for protein–protein, antibody–antigen and Runs N' Poses with similarity below 40, with the cost of the confidence module included. Because sampling SimpleFold2 per seed is about 10× faster than OpenFold3-p2 and 3.6× faster than an ESMFold2, SimpleFold2's candidate pool at equal GPU time contains a correct structure as often as OpenFold3-p2's on protein–protein and more often on antibody–antigen. Since our main contribution is on the generative modeling side and not on the confidence prediction head we evaluate difference confidence prediction models for SimpleFold2 predicted structures. Using ESMFold2's confidence head, with its cost included, the SimpleFold2 obtains 41.2% SR on antibody–antigen at ten minutes, compared with OpenFold3-p2 (40.3%), and 67.2% on protein–protein, against 71.7% for OpenFold3-p2. Our confidence module does not yet pick these structures reliably, so our ranked success stays below both baselines on FoldBench and we plan to address issues in confidence head prediction in future work.

  • We also agree that Appendix G undercuts our framing. Therefore, we have revised the draft to clarify the claims of new Pareto boundaries existing mostly for protein-ligand complexes.

AuthorsOpenReview ↗

Official Comment from Authors to Reviewer PnAh (2)

Q4. Inference configuration for baseline models.

  • In the paper, we report the results of baseline models following their official implementations. In particular, we ran OpenFold3-p2 as released, in fp32 with its default DeepSpeed attention kernel, and ESMFold2 with its fused Triton triangle kernels (Appendix F). Faster kernels such as cuEquivariance, as well as bf16 inference, can speed up AlphaFold3-style models further, but optimizing the baselines is beyond the scope of this work. At matched precision, SimpleFold2 is 1.3–1.6× faster than OpenFold3-p2 when both run in fp32 without compilation, and 3–4.5× faster than ESMFold2 when both run in bf16 (see general response #3). The per-seed times include the language-model embedding but not the MSA search, which is excluded for all models.

  • As suggested, we also measured how the number of trunk passes and the MSA depth affect the cost and accuracy of all three models (Table 8 in Appendix I). The table below reports the cost per seed and the average accuracy over 25 samples per target: protein–protein success and protein monomer lDDT on FoldBench, and success on Runs N' Poses.

SettingCost per seed (H100-s)Protein–protein success (%)Protein monomer lDDTRuns N' Poses success (%)
OpenFold3-p2 (default)42.871.20.88160.8
OpenFold3-p2, no recycle20.763.50.84447.3
OpenFold3-p2, no MSA or templates42.116.20.3940.7
ESMFold2 (default)15.773.00.88465.1
ESMFold2, no loop9.265.30.85452.3
ESMFold2, no MSA14.365.10.84364.7
SimpleFold2-3B (default)4.356.00.82564.2
SimpleFold2-3B, no MSA4.352.90.80664.8
  • Fewer trunk passes do not close the gap in cost. With a single pass, OpenFold3-p2 and ESMFold2 still need 20.7 s and 9.2 s per seed, about 5× and 2× SimpleFold2's 4.3 s, and both lose accuracy, including 7.7 points of protein–protein success and about 13 points on Runs N' Poses. Without its MSA and templates, OpenFold3-p2 collapses on every benchmark, with protein monomer lDDT dropping from 0.88 to 0.39 and Runs N' Poses success from 60.8% to 0.7%, while removing them saves it only 1.6% of its time (42.1 s instead of 42.8 s per seed). Meanwhile, without its MSA, ESMFold2 loses 7.9 points of protein–protein success and 0.041 monomer lDDT, while Runs N' Poses is nearly unchanged, at 14.3 s per seed instead of 15.7 s. SimpleFold2 depends less on its MSA, which demonstrates SimpleFold2's efficiency advantage even when compared with OpenFold3-p2 and ESMFold2 with more efficient configuration in inference, which are cheaper and less performant than their default settings.

Q5. Results on large assemblies (Fig. 15).

  • We thank the reviewer for pointing this out. We would like to clarify that Fig. 15 is meant to show that SimpleFold2 can run inference on assemblies of this size on a single GPU without further optimization. We agree that the capsid predictions in the bottom row of Fig. 15 are not correct. We have revised the caption and the text to make this clear.

Q6. Evaluation of PDB-only model.

  • We compared the PDB-only 3B model with the model trained with 50% distilled data at the same training step (140k), averaging over 25 samples per target on FoldBench and Runs N' Poses.
PDB-onlywith OpenFold3 distilled data
Protein–protein success47.4%50.8%
Protein–ligand success39.4%41.7%
Protein monomer lDDT0.7720.814
Runs N' Poses success63.2%65.7%
  • Trained on PDB structures alone, SimpleFold2 maintains most of its original accuracy. Removing the distilled data costs 2.3–3.4 points of success on protein–protein, protein–ligand and Runs N' Poses, and it even improves protein–RNA by 8.9 points and protein–DNA by 1.5 points. The largest losses are on protein monomers (0.042 lDDT) and protein–peptide (8.3 points), where the distilled protein monomers are most relevant. SimpleFold2's accuracy therefore does not come mainly from distilling data AlphaFold-style models; distillation mainly helps on protein monomers and peptides. Section 4.6 now states this, and we have added this comparison to the appendix it refers to (Appendix K.3, Table 10).
Reviewer_PnAhOpenReview ↗

Response

Thank you for the rebuttal and revision. The September 2021 cutoff resolves my leakage concern, and I appreciate the narrowed triangle claim, the matched-precision timings, the corrected Fig. 15 framing, the PDB-only comparison, and the confidence-ranked results in Appendix J. These revisions, however, also narrow the paper’s claims: at matched precision the speedup over OpenFold3-p2 is 1.3–1.6×, ranked by its own confidence module SimpleFold2 stays below the strongest baseline on every test set, and matching OpenFold3-p2 requires ESMFold2’s confidence head and trunk. Also, the “new Pareto boundaries on protein-ligands” claim be restricted to oracle selection on Runs N’ Poses and protein–DNA, since the paper itself places SimpleFold2 below ESMFold2 on FoldBench protein–ligand. The revised paper is more accurate but more modest in scope, so I am keeping my score.

AuthorsOpenReview ↗

Official Comment from Authors

We thank the reviewer for participating in the rebuttal and acknowledging our work. We agree with the narrowed claims, which we think position the contribution more precisely.

Reviewer_8zHwOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

SimpleFold2 extends transformer-based flow matching from protein monomers to biomolecular co-folding. It combines frozen protein-language-model embeddings with an encoder and coordinate generator that omit pair representations and triangle updates. The main contribution beyond SimpleFold is this extension to heterogeneous complexes, with strong protein–ligand results and large reported inference savings.

Critical strengths
  • Amortizing the encoder across sampling steps and simplifying the generator addresses a real bottleneck. The 4,960-residue prediction on one H100 demonstrates feasibility.
  • Protein–ligand results are strong: 68.1% ranked and 77.7% oracle success on Runs N' Poses, matching AlphaFold3's oracle result; 36.8% vs 37.1% on the four lowest-similarity bins. OpenBind's validity requirement is a useful additional check.
  • The ablations cover conditioning, encoder allocation, sampling, and synthetic data. The PDB-only experiment shows useful performance without distilled structures.
Critical weaknesses
  1. Training/test separation is undocumented. Section 4.1 gives no release-date cutoff or benchmark exclusion procedure. Runs N' Poses selects post-cutoff systems and computes pocket similarity against a fixed earlier training set; FoldBench uses PDB entries after 2023-01-13. If the PDB snapshot extends past these dates, the low-similarity bins are not low-similarity for this model and the Section 4.2 generalization claim fails.

  2. Oracle scaling does not establish practical gains. Figures 1b, 5b–c, and 16 select with ground truth, and the ranking score is unspecified. The ranked-to-oracle gap (68.1% vs 77.7% on Runs N' Poses; 48.0% vs 63.3% on FoldBench protein–ligand) is comparable to the baselines', but Appendix B notes SimpleFold2's posterior has higher variance, which is exactly when best-of-kk curves overstate gains. The Pareto claims also need qualification: Figure 5c shows ESMFold2 above SimpleFold2 at every matched budget on protein–protein, contradicting Section 4.5, and Appendix G shows the same on antibody–antigen and protein–ligand. Figure 1b uses only the similarity-under-40 subset; the caption should say so.

  3. Architectural claims and cost accounting are overscoped. The confidence module (Section 3.1) builds a pair representation and uses triangle multiplication, so the abstract's "no triangle updates" holds for the generator only. A pair tensor at the 43,920-token scale of Figure 15 would not fit on one GPU, so those measurements exclude confidence. Table 5 compares bf16 compiled SimpleFold2 with fp32 OpenFold3-p2 at 10 recycles, which does not isolate architectural savings; the precision-matched ESMFold2 comparison still favors SimpleFold2 by roughly 4×.

  4. Training-compute efficiency is untested. Figure 1c compares 155M–3.3B models at 70k steps with no matched baseline curve or budget. Parameter counts are not comparable across Pairformer and transformer blocks.

Additional feedback: Data scarcity is offered as the cause of the protein–RNA and antibody–antigen deficits, but the baselines train on the same PDB and do better. Figure 8 also shows synthetic data hurting protein–RNA. Runs N' Poses instance count is 1,735 in Figure 3 and 1,738 in Section 4.2.

Questions for authors
  1. What cutoffs and exclusions were used for generator training, distilled data, confidence training, and model selection? Were the Runs N' Poses similarity bins recomputed against the actual training set?
  2. Which confidence score ranks samples? Please report confidence-ranked success against GPU time from the existing samples (Figures 1b, 5b–c, 16).
  3. Do the timings and memory measurements include the language-model encoders and confidence scoring? Please give a component breakdown.
  4. Please report training FLOPs or GPU-hours, separating frozen-encoder extraction and upstream pretraining.
4 comments
AuthorsOpenReview ↗

Official Comment from Authors to Reviewer 8zHw

Thank you for your detailed and constructive review. We respond to each point below.

Q1. Training data cutoffs and Runs N' Poses similarity bins.

  • We follow exactly the same PDB data cutoff as main co-folding models like AlphaFold3, OpenFold3, ESMFold2. Namely only PDB structures released before September 30, 2021 are included in training data, which makes the results comparable to other baseline models. Since we follow the same training data cutoff, we directly adopt the similarity bins as applied in the official Runs N' Poses benchmark to guarantee comparability to baseline models.

Q2. Ranked results in test-time scaling.

  • We now rank each model's samples by its own confidence score: on FoldBench, SimpleFold2 by the whole-complex pLDDT of its confidence module, OpenFold3-p2 by its ranking score and ESMFold2 by its global ipTM. Appendix J of the revised paper (Figs. 17 and 18) reports oracle and ranked success against GPU time per target, computed from the existing samples with the cost of the confidence module included, and general response #2 summarizes it. Because sampling SimpleFold2 per seed is about 10× faster than OpenFold3-p2 and 3.6× faster than an ESMFold2, SimpleFold2's candidate pool at equal GPU time contains a correct structure as often as OpenFold3-p2's on protein–protein and more often on antibody–antigen. Since our main contribution is on the generative modeling side and not on the confidence prediction head we evaluate difference confidence prediction models for SimpleFold2 predicted structures. Using ESMFold2's confidence head, with its cost included, the SimpleFold2 obtains 41.2% SR on antibody–antigen at ten minutes, compared with OpenFold3-p2 (40.3%), and 67.2% on protein–protein, against 71.7% for OpenFold3-p2. Our confidence module does not yet pick these structures reliably, so our ranked success stays below both baselines on FoldBench and we plan to address issues in confidence head prediction in future work.

Q3. Cost breakdown and scope of the claims.

  • General response #3 gives a component breakdown on H100 including pLM, encoding module, diffusion module and confidence module (Appendix I, Table 7). Sampling a SimpleFold2 seed takes 4.3 s on average: 3.1 s for diffusion, 0.6 s for the confidence module, 0.24 s for the language models and 0.4 s for input processing and overhead. OpenFold3-p2 and ESMFold2 need 42.8 s and 15.7 s with their default 11 trunk passes. With a single pass, OpenFold3-p2 and ESMFold2 still take 20.7 s and 9.2 s for inference and drop 8–28 performance points on several interface types.

  • As suggested, we also compare SimpleFold2 and OpenFold3-p2 in fp32 precision and without compilation, SimpleFold2 is 1.3–1.6× faster than OpenFold3-p2. In addition, benchmarking against ESMFold2 using both bf16 and fused triangle kernels shows that SimpleFold2 is 3–4.5× faster than ESMFold2. It should be noted that we ran OpenFold3-p2 as released, with its default DeepSpeed attention, and ESMFold2 with the fused Triton kernels documented in its repository. We are also aware that faster triangle kernels such as cuEquivariance, or bf16 inference for OpenFold3-p2, could speed them up further, however even in that case we still expect SimpleFold2 to dominate in terms of inference efficiency (see ESMFold2 results). We have updated the draft to clarify the implementation we follow in the inference cost benchmark (Appendices F and I).

Q4. Training FLOPs or GPU-hours.

  • Training SimpleFold2-3B, the checkpoint in Fig. 3, took 3.6 × 10^21 FLOPs and 13.7k B200-hours on 64 B200 GPUs (Appendix L of the revised paper). The frozen language models run on the fly during training and account for 3% of these FLOPs. Training the confidence module took another 1.6k B200-hours. Estimated from their reported training configurations, OpenFold3-p2 and ESMFold2 required about 8.0 × 10^21 and 7.5 × 10^21 FLOPs, roughly twice as much. SimpleFold2's training therefore took about half their compute. Besides, the training costs of pretrained pLM (e.g., ESMC) are not counted for either SimpleFold2 or ESMFold2 as these are trained once and reused during training the co-folding models. Appendix L lists them separately: 2.4 × 10^23 FLOPs for ESMC-6B, which ESMFold2 also uses, and an estimated 1.4 × 10^22 for E1-600M. It also gives the training compute of each model size in Fig. 1c (Table 11); the 3B model there was trained with twice the batch size.
AuthorsOpenReview ↗

Official Comment from Authors to Reviewer 8zHw (2)

Q5. Data scarcity.

  • We think the difference lies in how much each model has to learn from data. The architectures and training recipes of OpenFold3-p2 and ESMFold2 build in strong structural priors, most notably pair representations updated by triangle operations, and such priors help most where examples are few, as for antibody–antigen and protein–RNA interfaces. SimpleFold2 removes most of these priors from its generator and learns this geometry from data. It is therefore competitive where data are available as for protein monomers and protein–ligand complexes. Section 4.3 and the conclusion of the revised paper now give this explanation.

Q6. Runs N' Poses instance count.

  • All models in Runs N' Poses reported in this work are compared on the same 1,735 ligand instances. We have corrected it in the updated draft (Section 4.2).

Thank you for your response!

I still support acceptance of the paper and will maintain my current score.

In future work, it might be very interesting to fit scaling laws for validation loss (for example the distogram loss or MSE) both in terms of data and model parameters, and compare the scaling behavior with the most commonly used cofolding architectures.

AuthorsOpenReview ↗

Official Comment from Authors

We appreciate the reviewer for acknowledging our work and we agree that a rigorous study of scaling law for co-folding models can be a valuable future direction.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.